gcore 0.1.0a1__py3-none-any.whl

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"""

gcore/types/cloud/baremetal/server_list_params.py

@@ -0,0 +1,114 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import List, Union
+from datetime import datetime
+from typing_extensions import Literal, Annotated, TypedDict
+
+from ...._utils import PropertyInfo
+
+__all__ = ["ServerListParams"]
+
+
+class ServerListParams(TypedDict, total=False):
+    project_id: int
+    """Project ID"""
+
+    region_id: int
+    """Region ID"""
+
+    changes_before: Annotated[Union[str, datetime], PropertyInfo(alias="changes-before", format="iso8601")]
+    """Filters the instances by a date and time stamp when the instances last changed."""
+
+    changes_since: Annotated[Union[str, datetime], PropertyInfo(alias="changes-since", format="iso8601")]
+    """
+    Filters the instances by a date and time stamp when the instances last changed
+    status.
+    """
+
+    flavor_id: str
+    """Filter out instances by flavor_id. Flavor id must match exactly."""
+
+    flavor_prefix: str
+    """Filter out instances by flavor_prefix."""
+
+    include_k8s: bool
+    """Include managed k8s worker nodes"""
+
+    ip: str
+    """An IPv4 address to filter results by.
+
+    Note: partial matches are allowed. For example, searching for 192.168.0.1 will
+    return 192.168.0.1, 192.168.0.10, 192.168.0.110, and so on.
+    """
+
+    limit: int
+    """Optional. Limit the number of returned items"""
+
+    name: str
+    """Filter instances by name.
+
+    You can provide a full or partial name, instances with matching names will be
+    returned. For example, entering 'test' will return all instances that contain
+    'test' in their name.
+    """
+
+    offset: int
+    """Optional.
+
+    Offset value is used to exclude the first set of records from the result
+    """
+
+    only_isolated: bool
+    """Include only isolated instances"""
+
+    only_with_fixed_external_ip: bool
+    """Return bare metals only with external fixed IP addresses."""
+
+    order_by: Literal["created.asc", "created.desc", "name.asc", "name.desc", "status.asc", "status.desc"]
+    """Order by field and direction."""
+
+    profile_name: str
+    """Filter result by ddos protection profile name.
+
+    Effective only with with_ddos set to true.
+    """
+
+    protection_status: Literal["Active", "Queued", "Error"]
+    """Filter result by DDoS protection_status.
+
+    Effective only with with_ddos set to true. (Active, Queued or Error)
+    """
+
+    status: Literal["ACTIVE", "BUILD", "ERROR", "HARD_REBOOT", "REBOOT", "REBUILD", "RESCUE", "SHUTOFF", "SUSPENDED"]
+    """Filters instances by a server status, as a string."""
+
+    tag_key_value: str
+    """Optional.
+
+    Filter by tag key-value pairs. curl -G --data-urlencode "tag_key_value={"key":
+    "value"}" --url "https://example.com/cloud/v1/resource/1/1"
+    """
+
+    tag_value: List[str]
+    """Optional. Filter by tag values. ?tag_value=value1&tag_value=value2"""
+
+    type_ddos_profile: Literal["basic", "advanced"]
+    """Return bare metals either only with advanced or only basic DDoS protection.
+
+    Effective only with with_ddos set to true. (advanced or basic)
+    """
+
+    uuid: str
+    """Filter the server list result by the UUID of the server. Allowed UUID part"""
+
+    with_ddos: bool
+    """
+    Include DDoS profile information for bare-metal servers in the response when set
+    to `true`. Otherwise, the `ddos_profile` field in the response is `null` by
+    default.
+    """
+
+    with_interfaces_name: bool
+    """Include `interface_name` in the addresses"""

gcore/types/cloud/baremetal/server_rebuild_params.py

@@ -0,0 +1,23 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import TypedDict
+
+__all__ = ["ServerRebuildParams"]
+
+
+class ServerRebuildParams(TypedDict, total=False):
+    project_id: int
+
+    region_id: int
+
+    image_id: str
+    """Image ID"""
+
+    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
+    """

gcore/types/cloud/baremetal_flavor.py

@@ -0,0 +1,58 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["BaremetalFlavor"]
+
+
+class BaremetalFlavor(BaseModel):
+    architecture: str
+    """Flavor architecture type"""
+
+    disabled: bool
+    """Disabled flavor flag"""
+
+    flavor_id: str
+    """Flavor ID is the same as name"""
+
+    flavor_name: str
+    """Flavor name"""
+
+    os_type: str
+    """Flavor operating system"""
+
+    ram: int
+    """RAM size in MiB"""
+
+    resource_class: Optional[str] = None
+    """Flavor resource class for mapping to hardware capacity"""
+
+    vcpus: int
+    """Virtual CPU count. For bare metal flavors, it's a physical CPU count"""
+
+    capacity: Optional[int] = None
+    """Number of available instances of given configuration"""
+
+    currency_code: Optional[str] = None
+    """Currency code. Shown if the include_prices query parameter if set to true"""
+
+    hardware_description: Optional[Dict[str, str]] = None
+    """Additional hardware description"""
+
+    price_per_hour: Optional[float] = None
+    """Price per hour. Shown if the include_prices query parameter if set to true"""
+
+    price_per_month: Optional[float] = None
+    """Price per month. Shown if the include_prices query parameter if set to true"""
+
+    price_status: Optional[Literal["error", "hide", "show"]] = None
+    """Price status for the UI"""
+
+    reserved_in_stock: Optional[int] = None
+    """Count of reserved but not used nodes.
+
+    If a client don't have reservations for the flavor, it's None.
+    """

gcore/types/cloud/baremetal_flavor_list.py

@@ -0,0 +1,16 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List
+
+from ..._models import BaseModel
+from .baremetal_flavor import BaremetalFlavor
+
+__all__ = ["BaremetalFlavorList"]
+
+
+class BaremetalFlavorList(BaseModel):
+    count: int
+    """Number of objects"""
+
+    results: List[BaremetalFlavor]
+    """Objects"""