# coding: utf-8
"""
    InductivaWebAPI

    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)  # noqa: E501

    The version of the OpenAPI document: 0.1.0
    Generated by: https://openapi-generator.tech
"""

from datetime import date, datetime  # noqa: F401
import decimal  # noqa: F401
import functools  # noqa: F401
import io  # noqa: F401
import re  # noqa: F401
import typing  # noqa: F401
import typing_extensions  # noqa: F401
import uuid  # noqa: F401

import frozendict  # noqa: F401

from inductiva.client import schemas  # noqa: F401


class InstanceGroupCreate(schemas.DictSchema):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.

    Schema for creating an instance group.

This schema is a blueprint for both elastic and non-elastic instance
groups. While most parameters are common, elastic instance groups include
'min_instances' and 'max_instances' options. These parameters remain in this
schema for consistency, as other functionalities like request validation,
instance deletion, and pricing calculations rely on the same parameters in
both instance group types.
    """

    class MetaOapg:
        required = {
            "machine_type",
            "spot",
            "is_elastic",
            "disk_size_gb",
            "num_instances",
        }

        class properties:
            machine_type = schemas.StrSchema
            spot = schemas.BoolSchema
            disk_size_gb = schemas.IntSchema
            num_instances = schemas.IntSchema
            is_elastic = schemas.BoolSchema
            zone = schemas.StrSchema

            class min_instances(
                    schemas.ComposedSchema,):

                class MetaOapg:
                    any_of_0 = schemas.IntSchema
                    any_of_1 = schemas.NoneSchema

                    @classmethod
                    @functools.lru_cache()
                    def any_of(cls):
                        # we need this here to make our import statements work
                        # we must store _composed_schemas in here so the code is only run
                        # when we invoke this method. If we kept this at the class
                        # level we would get an error because the class level
                        # code would be run when this module is imported, and these composed
                        # classes don't exist yet because their module has not finished
                        # loading
                        return [
                            cls.any_of_0,
                            cls.any_of_1,
                        ]

                def __new__(
                    cls,
                    *_args: typing.Union[
                        dict,
                        frozendict.frozendict,
                        str,
                        date,
                        datetime,
                        uuid.UUID,
                        int,
                        float,
                        decimal.Decimal,
                        bool,
                        None,
                        list,
                        tuple,
                        bytes,
                        io.FileIO,
                        io.BufferedReader,
                    ],
                    _configuration: typing.Optional[
                        schemas.Configuration] = None,
                    **kwargs: typing.Union[schemas.AnyTypeSchema, dict,
                                           frozendict.frozendict, str, date,
                                           datetime, uuid.UUID, int, float,
                                           decimal.Decimal, None, list, tuple,
                                           bytes],
                ) -> 'min_instances':
                    return super().__new__(
                        cls,
                        *_args,
                        _configuration=_configuration,
                        **kwargs,
                    )

            class max_instances(
                    schemas.ComposedSchema,):

                class MetaOapg:
                    any_of_0 = schemas.IntSchema
                    any_of_1 = schemas.NoneSchema

                    @classmethod
                    @functools.lru_cache()
                    def any_of(cls):
                        # we need this here to make our import statements work
                        # we must store _composed_schemas in here so the code is only run
                        # when we invoke this method. If we kept this at the class
                        # level we would get an error because the class level
                        # code would be run when this module is imported, and these composed
                        # classes don't exist yet because their module has not finished
                        # loading
                        return [
                            cls.any_of_0,
                            cls.any_of_1,
                        ]

                def __new__(
                    cls,
                    *_args: typing.Union[
                        dict,
                        frozendict.frozendict,
                        str,
                        date,
                        datetime,
                        uuid.UUID,
                        int,
                        float,
                        decimal.Decimal,
                        bool,
                        None,
                        list,
                        tuple,
                        bytes,
                        io.FileIO,
                        io.BufferedReader,
                    ],
                    _configuration: typing.Optional[
                        schemas.Configuration] = None,
                    **kwargs: typing.Union[schemas.AnyTypeSchema, dict,
                                           frozendict.frozendict, str, date,
                                           datetime, uuid.UUID, int, float,
                                           decimal.Decimal, None, list, tuple,
                                           bytes],
                ) -> 'max_instances':
                    return super().__new__(
                        cls,
                        *_args,
                        _configuration=_configuration,
                        **kwargs,
                    )

            __annotations__ = {
                "machine_type": machine_type,
                "spot": spot,
                "disk_size_gb": disk_size_gb,
                "num_instances": num_instances,
                "is_elastic": is_elastic,
                "zone": zone,
                "min_instances": min_instances,
                "max_instances": max_instances,
            }

    machine_type: MetaOapg.properties.machine_type
    spot: MetaOapg.properties.spot
    is_elastic: MetaOapg.properties.is_elastic
    disk_size_gb: MetaOapg.properties.disk_size_gb
    num_instances: MetaOapg.properties.num_instances

    @typing.overload
    def __getitem__(
        self, name: typing_extensions.Literal["machine_type"]
    ) -> MetaOapg.properties.machine_type:
        ...

    @typing.overload
    def __getitem__(
            self, name: typing_extensions.Literal["spot"]
    ) -> MetaOapg.properties.spot:
        ...

    @typing.overload
    def __getitem__(
        self, name: typing_extensions.Literal["disk_size_gb"]
    ) -> MetaOapg.properties.disk_size_gb:
        ...

    @typing.overload
    def __getitem__(
        self, name: typing_extensions.Literal["num_instances"]
    ) -> MetaOapg.properties.num_instances:
        ...

    @typing.overload
    def __getitem__(
        self, name: typing_extensions.Literal["is_elastic"]
    ) -> MetaOapg.properties.is_elastic:
        ...

    @typing.overload
    def __getitem__(
            self, name: typing_extensions.Literal["zone"]
    ) -> MetaOapg.properties.zone:
        ...

    @typing.overload
    def __getitem__(
        self, name: typing_extensions.Literal["min_instances"]
    ) -> MetaOapg.properties.min_instances:
        ...

    @typing.overload
    def __getitem__(
        self, name: typing_extensions.Literal["max_instances"]
    ) -> MetaOapg.properties.max_instances:
        ...

    @typing.overload
    def __getitem__(self, name: str) -> schemas.UnsetAnyTypeSchema:
        ...

    def __getitem__(self, name: typing.Union[typing_extensions.Literal[
        "machine_type",
        "spot",
        "disk_size_gb",
        "num_instances",
        "is_elastic",
        "zone",
        "min_instances",
        "max_instances",
    ], str]):
        # dict_instance[name] accessor
        return super().__getitem__(name)

    @typing.overload
    def get_item_oapg(
        self, name: typing_extensions.Literal["machine_type"]
    ) -> MetaOapg.properties.machine_type:
        ...

    @typing.overload
    def get_item_oapg(
            self, name: typing_extensions.Literal["spot"]
    ) -> MetaOapg.properties.spot:
        ...

    @typing.overload
    def get_item_oapg(
        self, name: typing_extensions.Literal["disk_size_gb"]
    ) -> MetaOapg.properties.disk_size_gb:
        ...

    @typing.overload
    def get_item_oapg(
        self, name: typing_extensions.Literal["num_instances"]
    ) -> MetaOapg.properties.num_instances:
        ...

    @typing.overload
    def get_item_oapg(
        self, name: typing_extensions.Literal["is_elastic"]
    ) -> MetaOapg.properties.is_elastic:
        ...

    @typing.overload
    def get_item_oapg(
        self, name: typing_extensions.Literal["zone"]
    ) -> typing.Union[MetaOapg.properties.zone, schemas.Unset]:
        ...

    @typing.overload
    def get_item_oapg(
        self, name: typing_extensions.Literal["min_instances"]
    ) -> typing.Union[MetaOapg.properties.min_instances, schemas.Unset]:
        ...

    @typing.overload
    def get_item_oapg(
        self, name: typing_extensions.Literal["max_instances"]
    ) -> typing.Union[MetaOapg.properties.max_instances, schemas.Unset]:
        ...

    @typing.overload
    def get_item_oapg(
            self, name: str
    ) -> typing.Union[schemas.UnsetAnyTypeSchema, schemas.Unset]:
        ...

    def get_item_oapg(self, name: typing.Union[typing_extensions.Literal[
        "machine_type",
        "spot",
        "disk_size_gb",
        "num_instances",
        "is_elastic",
        "zone",
        "min_instances",
        "max_instances",
    ], str]):
        return super().get_item_oapg(name)

    def __new__(
        cls,
        *_args: typing.Union[
            dict,
            frozendict.frozendict,
        ],
        machine_type: typing.Union[
            MetaOapg.properties.machine_type,
            str,
        ],
        spot: typing.Union[
            MetaOapg.properties.spot,
            bool,
        ],
        is_elastic: typing.Union[
            MetaOapg.properties.is_elastic,
            bool,
        ],
        disk_size_gb: typing.Union[
            MetaOapg.properties.disk_size_gb,
            decimal.Decimal,
            int,
        ],
        num_instances: typing.Union[
            MetaOapg.properties.num_instances,
            decimal.Decimal,
            int,
        ],
        zone: typing.Union[MetaOapg.properties.zone, str,
                           schemas.Unset] = schemas.unset,
        min_instances: typing.Union[MetaOapg.properties.min_instances, dict,
                                    frozendict.frozendict, str, date, datetime,
                                    uuid.UUID, int, float, decimal.Decimal,
                                    bool, None, list, tuple, bytes, io.FileIO,
                                    io.BufferedReader,
                                    schemas.Unset] = schemas.unset,
        max_instances: typing.Union[MetaOapg.properties.max_instances, dict,
                                    frozendict.frozendict, str, date, datetime,
                                    uuid.UUID, int, float, decimal.Decimal,
                                    bool, None, list, tuple, bytes, io.FileIO,
                                    io.BufferedReader,
                                    schemas.Unset] = schemas.unset,
        _configuration: typing.Optional[schemas.Configuration] = None,
        **kwargs: typing.Union[schemas.AnyTypeSchema, dict,
                               frozendict.frozendict, str, date, datetime,
                               uuid.UUID, int, float, decimal.Decimal, None,
                               list, tuple, bytes],
    ) -> 'InstanceGroupCreate':
        return super().__new__(
            cls,
            *_args,
            machine_type=machine_type,
            spot=spot,
            is_elastic=is_elastic,
            disk_size_gb=disk_size_gb,
            num_instances=num_instances,
            zone=zone,
            min_instances=min_instances,
            max_instances=max_instances,
            _configuration=_configuration,
            **kwargs,
        )
