# coding: utf-8 """ Kubernetes No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) The version of the OpenAPI document: release-1.37 Generated by OpenAPI Generator (https://openapi-generator.tech) Do not edit the class manually. """ # noqa: E501 from __future__ import annotations import pprint import re # noqa: F401 import json from collections.abc import Mapping as _Mapping from pydantic import AliasChoices, BaseModel, ConfigDict, Field, ModelWrapValidatorHandler as _ModelWrapValidatorHandler, model_validator as _model_validator from typing import Any, ClassVar, Dict, List, Optional, cast as _cast from kubernetes.aio.client.models.v1_exec_action import V1ExecAction from kubernetes.aio.client.models.v1_http_get_action import V1HTTPGetAction from kubernetes.aio.client.models.v1_sleep_action import V1SleepAction from kubernetes.aio.client.models.v1_tcp_socket_action import V1TCPSocketAction from typing import Optional, Set from typing_extensions import Self from pydantic_core import to_jsonable_python from typing import TYPE_CHECKING _OPENAPI_GENERATOR_TO_DICT = "_openapi_generator_to_dict" def _get_openapi_to_dict(value: Any) -> Any: # Reciprocal function references preserve inherited generated methods # without reserving model member names. Checking both directions also # rejects overrides whose decorators copy function attributes. to_dict = getattr(value, "to_dict", None) type_to_dict = getattr(type(value), "to_dict", None) if ( not callable(to_dict) or getattr(to_dict, "__func__", None) is not type_to_dict ): return None openapi_to_dict = getattr( type_to_dict, _OPENAPI_GENERATOR_TO_DICT, None ) if ( not callable(openapi_to_dict) or getattr( openapi_to_dict, _OPENAPI_GENERATOR_TO_DICT, None, ) is not type_to_dict ): return None return openapi_to_dict def _to_legacy_item(value: Any, serialize: bool) -> Any: to_dict = getattr(value, "to_dict", None) if _get_openapi_to_dict(value) is not None and callable(to_dict): return to_dict(serialize=serialize) if callable(to_dict): return to_dict() return value def _to_legacy_value(value: Any, serialize: bool) -> Any: # python-legacy converted only immediate list elements or dictionary values: # https://github.com/OpenAPITools/openapi-generator/blob/c84b949df1a9ec04ba75989cb49b45c940c2f694/modules/openapi-generator/src/main/resources/python-legacy/model.mustache#L203-L231 if isinstance(value, list): return [_to_legacy_item(item, serialize) for item in value] if isinstance(value, dict): return { key: _to_legacy_item(item, serialize) for key, item in value.items() } return _to_legacy_item(value, serialize) def _to_openapi_value(value: Any) -> Any: if isinstance(value, list): return [_to_openapi_value(item) for item in value] if isinstance(value, dict): return {key: _to_openapi_value(item) for key, item in value.items()} to_openapi_dict = _get_openapi_to_dict(value) if to_openapi_dict is not None: return to_openapi_dict(value) to_dict = getattr(value, "to_dict", None) if callable(to_dict): return to_dict() return value class V1LifecycleHandler(BaseModel): """ LifecycleHandler defines a specific action that should be taken in a lifecycle hook. One and only one of the fields, except TCPSocket must be specified. Attributes: openapi_types (dict): The key is attribute name and the value is attribute type. attribute_map (dict): The key is attribute name and the value is json key in definition. """ # noqa: E501 var_exec: Optional[V1ExecAction] = Field(default=None, validation_alias=AliasChoices("exec", "_exec"), serialization_alias="exec", alias="_exec") http_get: Optional[V1HTTPGetAction] = Field(default=None, validation_alias=AliasChoices("httpGet", "http_get"), serialization_alias="httpGet") sleep: Optional[V1SleepAction] = None tcp_socket: Optional[V1TCPSocketAction] = Field(default=None, validation_alias=AliasChoices("tcpSocket", "tcp_socket"), serialization_alias="tcpSocket") openapi_types: ClassVar[Dict[str, str]] = { "_exec": "V1ExecAction", "http_get": "V1HTTPGetAction", "sleep": "V1SleepAction", "tcp_socket": "V1TCPSocketAction" } attribute_map: ClassVar[Dict[str, str]] = { "_exec": "exec", "http_get": "httpGet", "sleep": "sleep", "tcp_socket": "tcpSocket" } __properties: ClassVar[List[str]] = ["exec", "httpGet", "sleep", "tcpSocket"] @classmethod def __preprocess_input_names( cls, obj: Any, remove_hidden_storage_names: bool = True, ) -> Any: if not isinstance(obj, _Mapping): return obj obj = dict(obj) if ( "exec" in obj and "_exec" in obj ): raise ValueError( "%s received both %r and %r" % ( cls.__name__, "exec", "_exec", ) ) if "exec" not in obj and "_exec" in obj: obj["exec"] = obj["_exec"] obj.pop("_exec", None) if "httpGet" not in obj and "http_get" in obj: obj["httpGet"] = obj["http_get"] obj.pop("http_get", None) if "tcpSocket" not in obj and "tcp_socket" in obj: obj["tcpSocket"] = obj["tcp_socket"] obj.pop("tcp_socket", None) if remove_hidden_storage_names: obj.pop("var_exec", None) return obj # Pydantic passes the model instance to wrap validators during assignment: # https://docs.pydantic.dev/2.11/migration/#changes-to-validators # Private names also keep inherited model validators distinct: # https://docs.pydantic.dev/2.11/concepts/validators/#on-inheritance @_model_validator(mode="wrap") @classmethod def __validate_input_names( cls, obj: Any, handler: _ModelWrapValidatorHandler[Self], ) -> Self: if not isinstance(obj, cls): obj = cls.__preprocess_input_names(obj) return handler(obj) model_config = ConfigDict( validate_by_name=True, validate_by_alias=True, validate_assignment=True, extra="forbid", protected_namespaces=(), ) def to_str(self) -> str: """Returns the string representation of the model""" return pprint.pformat(self.to_dict()) def __repr__(self) -> str: """For print and pprint""" return self.to_str() def __eq__(self, other: object) -> bool: """Returns true if both objects are equal""" if not isinstance(other, V1LifecycleHandler): return False return self.to_dict() == other.to_dict() def __ne__(self, other: object) -> bool: """Returns true if both objects are not equal""" if not isinstance(other, V1LifecycleHandler): return True return not (self == other) def to_json(self) -> str: """Returns the JSON representation of the model using alias""" to_openapi_dict = _get_openapi_to_dict(self) if to_openapi_dict is not None: return json.dumps(to_jsonable_python(to_openapi_dict(self))) return json.dumps(to_jsonable_python(self.to_dict())) @classmethod def from_json(cls, json_str: str) -> Optional[Self]: """Create an instance of V1LifecycleHandler from a JSON string""" return cls.from_dict(json.loads(json_str)) def to_dict(self, serialize: bool = False) -> Dict[str, Any]: """Return all declared model fields using public or wire names.""" return { ("exec" if serialize else "_exec"): _to_legacy_value(getattr(self, "var_exec", None), serialize), ("httpGet" if serialize else "http_get"): _to_legacy_value(getattr(self, "http_get", None), serialize), ("sleep" if serialize else "sleep"): _to_legacy_value(getattr(self, "sleep", None), serialize), ("tcpSocket" if serialize else "tcp_socket"): _to_legacy_value(getattr(self, "tcp_socket", None), serialize), } def __openapi_generator_modern_projection(self) -> Dict[str, Any]: """Return the dictionary representation of the model using alias. This has the following differences from calling pydantic's `self.model_dump(by_alias=True)`: * `None` is only added to the output dict for nullable fields that were set at model initialization. Other fields with value `None` are ignored. """ excluded_fields: Set[str] = set([ ]) _dict = self.model_dump( by_alias=True, exclude=excluded_fields, exclude_none=True, ) # override the default output from pydantic by calling `to_dict()` of var_exec if self.var_exec: _dict['exec'] = _to_openapi_value(self.var_exec) # override the default output from pydantic by calling `to_dict()` of http_get if self.http_get: _dict['httpGet'] = _to_openapi_value(self.http_get) # override the default output from pydantic by calling `to_dict()` of sleep if self.sleep: _dict['sleep'] = _to_openapi_value(self.sleep) # override the default output from pydantic by calling `to_dict()` of tcp_socket if self.tcp_socket: _dict['tcpSocket'] = _to_openapi_value(self.tcp_socket) return _dict setattr( to_dict, _OPENAPI_GENERATOR_TO_DICT, __openapi_generator_modern_projection, ) setattr( __openapi_generator_modern_projection, _OPENAPI_GENERATOR_TO_DICT, to_dict, ) del __openapi_generator_modern_projection @classmethod def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]: """Create an instance of V1LifecycleHandler from a dict""" if obj is None: return None if not isinstance(obj, dict): return cls.model_validate(obj) obj = _cast( Dict[str, Any], cls.__preprocess_input_names( obj, remove_hidden_storage_names=True, ), ) _obj = cls.model_validate({ "exec": V1ExecAction.from_dict(obj["exec"]) if obj.get("exec") is not None else None, "httpGet": V1HTTPGetAction.from_dict(obj["httpGet"]) if obj.get("httpGet") is not None else None, "sleep": V1SleepAction.from_dict(obj["sleep"]) if obj.get("sleep") is not None else None, "tcpSocket": V1TCPSocketAction.from_dict(obj["tcpSocket"]) if obj.get("tcpSocket") is not None else None }) return _obj if TYPE_CHECKING: @property def _exec(self) -> _V1LifecycleHandler_var_exec_public_type: return self.var_exec @_exec.setter def _exec(self, value: _V1LifecycleHandler_var_exec_public_type) -> None: self.var_exec = value if TYPE_CHECKING: _V1LifecycleHandler_var_exec_public_type = Optional[V1ExecAction] # Install forwarding properties after Pydantic has consumed the class # namespace and resolved any postponed model annotations. setattr( V1LifecycleHandler, "_exec", property( lambda self: self.var_exec, lambda self, value: setattr( self, "var_exec", value, ), ), )