kubernetes.client.models package

Submodules

Module contents

Kubernetes

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

The version of the OpenAPI document: release-1.36 Generated by OpenAPI Generator (https://openapi-generator.tech)

Do not edit the class manually.

class kubernetes.client.models.AdmissionregistrationV1ServiceReference(*, name: Annotated[str, Strict(strict=True)], namespace: Annotated[str, Strict(strict=True)], path: Annotated[str, Strict(strict=True)] | None = None, port: Annotated[int, Strict(strict=True)] | None = None)

Bases: BaseModel

ServiceReference holds a reference to Service.legacy.k8s.io

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.

attribute_map: ClassVar[Dict[str, str]] = {'name': 'name', 'namespace': 'namespace', 'path': 'path', 'port': 'port'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of AdmissionregistrationV1ServiceReference from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of AdmissionregistrationV1ServiceReference from a JSON string

model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: StrictStr
namespace: StrictStr
openapi_types: ClassVar[Dict[str, str]] = {'name': 'str', 'namespace': 'str', 'path': 'str', 'port': 'int'}
path: StrictStr | None
port: StrictInt | None
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.AdmissionregistrationV1WebhookClientConfig(*, ca_bundle: Annotated[bytes, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True)])] | Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True)])] | None = None, service: AdmissionregistrationV1ServiceReference | None = None, url: Annotated[str, Strict(strict=True)] | None = None)

Bases: BaseModel

WebhookClientConfig contains the information to make a TLS connection with the webhook

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.

attribute_map: ClassVar[Dict[str, str]] = {'ca_bundle': 'caBundle', 'service': 'service', 'url': 'url'}
ca_bundle: Annotated[bytes, Field(strict=True)] | Annotated[str, Field(strict=True)] | None
classmethod ca_bundle_validate_regular_expression(value)

Validates the regular expression

classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of AdmissionregistrationV1WebhookClientConfig from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of AdmissionregistrationV1WebhookClientConfig from a JSON string

model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'ca_bundle': 'bytes', 'service': 'AdmissionregistrationV1ServiceReference', 'url': 'str'}
service: AdmissionregistrationV1ServiceReference | None
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

url: StrictStr | None
class kubernetes.client.models.ApiextensionsV1ServiceReference(*, name: Annotated[str, Strict(strict=True)], namespace: Annotated[str, Strict(strict=True)], path: Annotated[str, Strict(strict=True)] | None = None, port: Annotated[int, Strict(strict=True)] | None = None)

Bases: BaseModel

ServiceReference holds a reference to Service.legacy.k8s.io

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.

attribute_map: ClassVar[Dict[str, str]] = {'name': 'name', 'namespace': 'namespace', 'path': 'path', 'port': 'port'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of ApiextensionsV1ServiceReference from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of ApiextensionsV1ServiceReference from a JSON string

model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: StrictStr
namespace: StrictStr
openapi_types: ClassVar[Dict[str, str]] = {'name': 'str', 'namespace': 'str', 'path': 'str', 'port': 'int'}
path: StrictStr | None
port: StrictInt | None
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.ApiextensionsV1WebhookClientConfig(*, ca_bundle: Annotated[bytes, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True)])] | Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True)])] | None = None, service: ApiextensionsV1ServiceReference | None = None, url: Annotated[str, Strict(strict=True)] | None = None)

Bases: BaseModel

WebhookClientConfig contains the information to make a TLS connection with the webhook.

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.

attribute_map: ClassVar[Dict[str, str]] = {'ca_bundle': 'caBundle', 'service': 'service', 'url': 'url'}
ca_bundle: Annotated[bytes, Field(strict=True)] | Annotated[str, Field(strict=True)] | None
classmethod ca_bundle_validate_regular_expression(value)

Validates the regular expression

classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of ApiextensionsV1WebhookClientConfig from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of ApiextensionsV1WebhookClientConfig from a JSON string

model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'ca_bundle': 'bytes', 'service': 'ApiextensionsV1ServiceReference', 'url': 'str'}
service: ApiextensionsV1ServiceReference | None
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

url: StrictStr | None
class kubernetes.client.models.ApiregistrationV1ServiceReference(*, name: Annotated[str, Strict(strict=True)] | None = None, namespace: Annotated[str, Strict(strict=True)] | None = None, port: Annotated[int, Strict(strict=True)] | None = None)

Bases: BaseModel

ServiceReference holds a reference to Service.legacy.k8s.io

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.

attribute_map: ClassVar[Dict[str, str]] = {'name': 'name', 'namespace': 'namespace', 'port': 'port'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of ApiregistrationV1ServiceReference from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of ApiregistrationV1ServiceReference from a JSON string

model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: StrictStr | None
namespace: StrictStr | None
openapi_types: ClassVar[Dict[str, str]] = {'name': 'str', 'namespace': 'str', 'port': 'int'}
port: StrictInt | None
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.AuthenticationV1TokenRequest(*, api_version: Annotated[str, Strict(strict=True)] | None = None, kind: Annotated[str, Strict(strict=True)] | None = None, metadata: V1ObjectMeta | None = None, spec: V1TokenRequestSpec | None = None, status: V1TokenRequestStatus | None = None)

Bases: BaseModel

TokenRequest requests a token for a given service account.

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.

api_version: StrictStr | None
attribute_map: ClassVar[Dict[str, str]] = {'api_version': 'apiVersion', 'kind': 'kind', 'metadata': 'metadata', 'spec': 'spec', 'status': 'status'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of AuthenticationV1TokenRequest from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of AuthenticationV1TokenRequest from a JSON string

kind: StrictStr | None
metadata: V1ObjectMeta | None
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'api_version': 'str', 'kind': 'str', 'metadata': 'V1ObjectMeta', 'spec': 'V1TokenRequestSpec', 'status': 'V1TokenRequestStatus'}
spec: V1TokenRequestSpec | None
status: V1TokenRequestStatus | None
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.CoreV1EndpointPort(*, app_protocol: Annotated[str, Strict(strict=True)] | None = None, name: Annotated[str, Strict(strict=True)] | None = None, port: Annotated[int, Strict(strict=True)], protocol: Annotated[str, Strict(strict=True)] | None = None)

Bases: BaseModel

EndpointPort is a tuple that describes a single port. Deprecated: This API is deprecated in v1.33+.

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.

app_protocol: StrictStr | None
attribute_map: ClassVar[Dict[str, str]] = {'app_protocol': 'appProtocol', 'name': 'name', 'port': 'port', 'protocol': 'protocol'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of CoreV1EndpointPort from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of CoreV1EndpointPort from a JSON string

model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: StrictStr | None
openapi_types: ClassVar[Dict[str, str]] = {'app_protocol': 'str', 'name': 'str', 'port': 'int', 'protocol': 'str'}
port: StrictInt
protocol: StrictStr | None
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.CoreV1Event(*, action: Annotated[str, Strict(strict=True)] | None = None, api_version: Annotated[str, Strict(strict=True)] | None = None, count: Annotated[int, Strict(strict=True)] | None = None, event_time: datetime | None = None, first_timestamp: datetime | None = None, involved_object: V1ObjectReference, kind: Annotated[str, Strict(strict=True)] | None = None, last_timestamp: datetime | None = None, message: Annotated[str, Strict(strict=True)] | None = None, metadata: V1ObjectMeta, reason: Annotated[str, Strict(strict=True)] | None = None, related: V1ObjectReference | None = None, reporting_component: Annotated[str, Strict(strict=True)] | None = None, reporting_instance: Annotated[str, Strict(strict=True)] | None = None, series: CoreV1EventSeries | None = None, source: V1EventSource | None = None, type: Annotated[str, Strict(strict=True)] | None = None)

Bases: BaseModel

Event is a report of an event somewhere in the cluster. Events have a limited retention time and triggers and messages may evolve with time. Event consumers should not rely on the timing of an event with a given Reason reflecting a consistent underlying trigger, or the continued existence of events with that Reason. Events should be treated as informative, best-effort, supplemental data.

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.

action: StrictStr | None
api_version: StrictStr | None
attribute_map: ClassVar[Dict[str, str]] = {'action': 'action', 'api_version': 'apiVersion', 'count': 'count', 'event_time': 'eventTime', 'first_timestamp': 'firstTimestamp', 'involved_object': 'involvedObject', 'kind': 'kind', 'last_timestamp': 'lastTimestamp', 'message': 'message', 'metadata': 'metadata', 'reason': 'reason', 'related': 'related', 'reporting_component': 'reportingComponent', 'reporting_instance': 'reportingInstance', 'series': 'series', 'source': 'source', 'type': 'type'}
count: StrictInt | None
event_time: datetime | None
first_timestamp: datetime | None
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of CoreV1Event from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of CoreV1Event from a JSON string

involved_object: V1ObjectReference
kind: StrictStr | None
last_timestamp: datetime | None
message: StrictStr | None
metadata: V1ObjectMeta
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'action': 'str', 'api_version': 'str', 'count': 'int', 'event_time': 'datetime', 'first_timestamp': 'datetime', 'involved_object': 'V1ObjectReference', 'kind': 'str', 'last_timestamp': 'datetime', 'message': 'str', 'metadata': 'V1ObjectMeta', 'reason': 'str', 'related': 'V1ObjectReference', 'reporting_component': 'str', 'reporting_instance': 'str', 'series': 'CoreV1EventSeries', 'source': 'V1EventSource', 'type': 'str'}
reason: StrictStr | None
related: V1ObjectReference | None
reporting_component: StrictStr | None
reporting_instance: StrictStr | None
series: CoreV1EventSeries | None
source: V1EventSource | None
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

type: StrictStr | None
class kubernetes.client.models.CoreV1EventList(*, api_version: Annotated[str, Strict(strict=True)] | None = None, items: List[CoreV1Event], kind: Annotated[str, Strict(strict=True)] | None = None, metadata: V1ListMeta | None = None)

Bases: BaseModel

EventList is a list of events.

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.

api_version: StrictStr | None
attribute_map: ClassVar[Dict[str, str]] = {'api_version': 'apiVersion', 'items': 'items', 'kind': 'kind', 'metadata': 'metadata'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of CoreV1EventList from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of CoreV1EventList from a JSON string

items: List[CoreV1Event]
kind: StrictStr | None
metadata: V1ListMeta | None
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'api_version': 'str', 'items': 'List[CoreV1Event]', 'kind': 'str', 'metadata': 'V1ListMeta'}
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.CoreV1EventSeries(*, count: Annotated[int, Strict(strict=True)] | None = None, last_observed_time: datetime | None = None)

Bases: BaseModel

EventSeries contain information on series of events, i.e. thing that was/is happening continuously for some time.

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.

attribute_map: ClassVar[Dict[str, str]] = {'count': 'count', 'last_observed_time': 'lastObservedTime'}
count: StrictInt | None
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of CoreV1EventSeries from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of CoreV1EventSeries from a JSON string

last_observed_time: datetime | None
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'count': 'int', 'last_observed_time': 'datetime'}
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.CoreV1ResourceClaim(*, name: Annotated[str, Strict(strict=True)], request: Annotated[str, Strict(strict=True)] | None = None)

Bases: BaseModel

ResourceClaim references one entry in PodSpec.ResourceClaims.

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.

attribute_map: ClassVar[Dict[str, str]] = {'name': 'name', 'request': 'request'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of CoreV1ResourceClaim from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of CoreV1ResourceClaim from a JSON string

model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: StrictStr
openapi_types: ClassVar[Dict[str, str]] = {'name': 'str', 'request': 'str'}
request: StrictStr | None
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.DiscoveryV1EndpointPort(*, app_protocol: Annotated[str, Strict(strict=True)] | None = None, name: Annotated[str, Strict(strict=True)] | None = None, port: Annotated[int, Strict(strict=True)] | None = None, protocol: Annotated[str, Strict(strict=True)] | None = None)

Bases: BaseModel

EndpointPort represents a Port used by an EndpointSlice

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.

app_protocol: StrictStr | None
attribute_map: ClassVar[Dict[str, str]] = {'app_protocol': 'appProtocol', 'name': 'name', 'port': 'port', 'protocol': 'protocol'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of DiscoveryV1EndpointPort from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of DiscoveryV1EndpointPort from a JSON string

model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: StrictStr | None
openapi_types: ClassVar[Dict[str, str]] = {'app_protocol': 'str', 'name': 'str', 'port': 'int', 'protocol': 'str'}
port: StrictInt | None
protocol: StrictStr | None
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.EventsV1Event(*, action: Annotated[str, Strict(strict=True)] | None = None, api_version: Annotated[str, Strict(strict=True)] | None = None, deprecated_count: Annotated[int, Strict(strict=True)] | None = None, deprecated_first_timestamp: datetime | None = None, deprecated_last_timestamp: datetime | None = None, deprecated_source: V1EventSource | None = None, event_time: datetime, kind: Annotated[str, Strict(strict=True)] | None = None, metadata: V1ObjectMeta | None = None, note: Annotated[str, Strict(strict=True)] | None = None, reason: Annotated[str, Strict(strict=True)] | None = None, regarding: V1ObjectReference | None = None, related: V1ObjectReference | None = None, reporting_controller: Annotated[str, Strict(strict=True)] | None = None, reporting_instance: Annotated[str, Strict(strict=True)] | None = None, series: EventsV1EventSeries | None = None, type: Annotated[str, Strict(strict=True)] | None = None)

Bases: BaseModel

Event is a report of an event somewhere in the cluster. It generally denotes some state change in the system. Events have a limited retention time and triggers and messages may evolve with time. Event consumers should not rely on the timing of an event with a given Reason reflecting a consistent underlying trigger, or the continued existence of events with that Reason. Events should be treated as informative, best-effort, supplemental data.

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.

action: StrictStr | None
api_version: StrictStr | None
attribute_map: ClassVar[Dict[str, str]] = {'action': 'action', 'api_version': 'apiVersion', 'deprecated_count': 'deprecatedCount', 'deprecated_first_timestamp': 'deprecatedFirstTimestamp', 'deprecated_last_timestamp': 'deprecatedLastTimestamp', 'deprecated_source': 'deprecatedSource', 'event_time': 'eventTime', 'kind': 'kind', 'metadata': 'metadata', 'note': 'note', 'reason': 'reason', 'regarding': 'regarding', 'related': 'related', 'reporting_controller': 'reportingController', 'reporting_instance': 'reportingInstance', 'series': 'series', 'type': 'type'}
deprecated_count: StrictInt | None
deprecated_first_timestamp: datetime | None
deprecated_last_timestamp: datetime | None
deprecated_source: V1EventSource | None
event_time: datetime
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of EventsV1Event from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of EventsV1Event from a JSON string

kind: StrictStr | None
metadata: V1ObjectMeta | None
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

note: StrictStr | None
openapi_types: ClassVar[Dict[str, str]] = {'action': 'str', 'api_version': 'str', 'deprecated_count': 'int', 'deprecated_first_timestamp': 'datetime', 'deprecated_last_timestamp': 'datetime', 'deprecated_source': 'V1EventSource', 'event_time': 'datetime', 'kind': 'str', 'metadata': 'V1ObjectMeta', 'note': 'str', 'reason': 'str', 'regarding': 'V1ObjectReference', 'related': 'V1ObjectReference', 'reporting_controller': 'str', 'reporting_instance': 'str', 'series': 'EventsV1EventSeries', 'type': 'str'}
reason: StrictStr | None
regarding: V1ObjectReference | None
related: V1ObjectReference | None
reporting_controller: StrictStr | None
reporting_instance: StrictStr | None
series: EventsV1EventSeries | None
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

type: StrictStr | None
class kubernetes.client.models.EventsV1EventList(*, api_version: Annotated[str, Strict(strict=True)] | None = None, items: List[EventsV1Event], kind: Annotated[str, Strict(strict=True)] | None = None, metadata: V1ListMeta | None = None)

Bases: BaseModel

EventList is a list of Event objects.

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.

api_version: StrictStr | None
attribute_map: ClassVar[Dict[str, str]] = {'api_version': 'apiVersion', 'items': 'items', 'kind': 'kind', 'metadata': 'metadata'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of EventsV1EventList from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of EventsV1EventList from a JSON string

items: List[EventsV1Event]
kind: StrictStr | None
metadata: V1ListMeta | None
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'api_version': 'str', 'items': 'List[EventsV1Event]', 'kind': 'str', 'metadata': 'V1ListMeta'}
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.EventsV1EventSeries(*, count: Annotated[int, Strict(strict=True)], last_observed_time: datetime)

Bases: BaseModel

EventSeries contain information on series of events, i.e. thing that was/is happening continuously for some time. How often to update the EventSeries is up to the event reporters. The default event reporter in “k8s.io/client-go/tools/events/event_broadcaster.go” shows how this struct is updated on heartbeats and can guide customized reporter implementations.

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.

attribute_map: ClassVar[Dict[str, str]] = {'count': 'count', 'last_observed_time': 'lastObservedTime'}
count: StrictInt
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of EventsV1EventSeries from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of EventsV1EventSeries from a JSON string

last_observed_time: datetime
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'count': 'int', 'last_observed_time': 'datetime'}
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.FlowcontrolV1Subject(*, group: V1GroupSubject | None = None, kind: Annotated[str, Strict(strict=True)], service_account: V1ServiceAccountSubject | None = None, user: V1UserSubject | None = None)

Bases: BaseModel

Subject matches the originator of a request, as identified by the request authentication system. There are three ways of matching an originator; by user, group, or service account.

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.

attribute_map: ClassVar[Dict[str, str]] = {'group': 'group', 'kind': 'kind', 'service_account': 'serviceAccount', 'user': 'user'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of FlowcontrolV1Subject from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of FlowcontrolV1Subject from a JSON string

group: V1GroupSubject | None
kind: StrictStr
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'group': 'V1GroupSubject', 'kind': 'str', 'service_account': 'V1ServiceAccountSubject', 'user': 'V1UserSubject'}
service_account: V1ServiceAccountSubject | None
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

user: V1UserSubject | None
class kubernetes.client.models.RbacV1Subject(*, api_group: Annotated[str, Strict(strict=True)] | None = None, kind: Annotated[str, Strict(strict=True)], name: Annotated[str, Strict(strict=True)], namespace: Annotated[str, Strict(strict=True)] | None = None)

Bases: BaseModel

Subject contains a reference to the object or user identities a role binding applies to. This can either hold a direct API object reference, or a value for non-objects such as user and group names.

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.

api_group: StrictStr | None
attribute_map: ClassVar[Dict[str, str]] = {'api_group': 'apiGroup', 'kind': 'kind', 'name': 'name', 'namespace': 'namespace'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of RbacV1Subject from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of RbacV1Subject from a JSON string

kind: StrictStr
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: StrictStr
namespace: StrictStr | None
openapi_types: ClassVar[Dict[str, str]] = {'api_group': 'str', 'kind': 'str', 'name': 'str', 'namespace': 'str'}
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.ResourceV1ResourceClaim(*, api_version: Annotated[str, Strict(strict=True)] | None = None, kind: Annotated[str, Strict(strict=True)] | None = None, metadata: V1ObjectMeta | None = None, spec: V1ResourceClaimSpec, status: V1ResourceClaimStatus | None = None)

Bases: BaseModel

ResourceClaim describes a request for access to resources in the cluster, for use by workloads. For example, if a workload needs an accelerator device with specific properties, this is how that request is expressed. The status stanza tracks whether this claim has been satisfied and what specific resources have been allocated.

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.

api_version: StrictStr | None
attribute_map: ClassVar[Dict[str, str]] = {'api_version': 'apiVersion', 'kind': 'kind', 'metadata': 'metadata', 'spec': 'spec', 'status': 'status'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of ResourceV1ResourceClaim from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of ResourceV1ResourceClaim from a JSON string

kind: StrictStr | None
metadata: V1ObjectMeta | None
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'api_version': 'str', 'kind': 'str', 'metadata': 'V1ObjectMeta', 'spec': 'V1ResourceClaimSpec', 'status': 'V1ResourceClaimStatus'}
spec: V1ResourceClaimSpec
status: V1ResourceClaimStatus | None
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.StorageV1TokenRequest(*, audience: Annotated[str, Strict(strict=True)], expiration_seconds: Annotated[int, Strict(strict=True)] | None = None)

Bases: BaseModel

TokenRequest contains parameters of a service account token.

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.

attribute_map: ClassVar[Dict[str, str]] = {'audience': 'audience', 'expiration_seconds': 'expirationSeconds'}
audience: StrictStr
expiration_seconds: StrictInt | None
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of StorageV1TokenRequest from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of StorageV1TokenRequest from a JSON string

model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'audience': 'str', 'expiration_seconds': 'int'}
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.V1APIGroup(*, api_version: Annotated[str, Strict(strict=True)] | None = None, kind: Annotated[str, Strict(strict=True)] | None = None, name: Annotated[str, Strict(strict=True)], preferred_version: V1GroupVersionForDiscovery | None = None, server_address_by_client_cidrs: List[V1ServerAddressByClientCIDR] | None = None, versions: List[V1GroupVersionForDiscovery])

Bases: BaseModel

APIGroup contains the name, the supported versions, and the preferred version of a group.

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.

api_version: StrictStr | None
attribute_map: ClassVar[Dict[str, str]] = {'api_version': 'apiVersion', 'kind': 'kind', 'name': 'name', 'preferred_version': 'preferredVersion', 'server_address_by_client_cidrs': 'serverAddressByClientCIDRs', 'versions': 'versions'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1APIGroup from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1APIGroup from a JSON string

kind: StrictStr | None
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: StrictStr
openapi_types: ClassVar[Dict[str, str]] = {'api_version': 'str', 'kind': 'str', 'name': 'str', 'preferred_version': 'V1GroupVersionForDiscovery', 'server_address_by_client_cidrs': 'List[V1ServerAddressByClientCIDR]', 'versions': 'List[V1GroupVersionForDiscovery]'}
preferred_version: V1GroupVersionForDiscovery | None
server_address_by_client_cidrs: List[V1ServerAddressByClientCIDR] | None
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

versions: List[V1GroupVersionForDiscovery]
class kubernetes.client.models.V1APIGroupList(*, api_version: Annotated[str, Strict(strict=True)] | None = None, groups: List[V1APIGroup], kind: Annotated[str, Strict(strict=True)] | None = None)

Bases: BaseModel

APIGroupList is a list of APIGroup, to allow clients to discover the API at /apis.

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.

api_version: StrictStr | None
attribute_map: ClassVar[Dict[str, str]] = {'api_version': 'apiVersion', 'groups': 'groups', 'kind': 'kind'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1APIGroupList from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1APIGroupList from a JSON string

groups: List[V1APIGroup]
kind: StrictStr | None
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'api_version': 'str', 'groups': 'List[V1APIGroup]', 'kind': 'str'}
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.V1APIResource(*, categories: List[Annotated[str, Strict(strict=True)]] | None = None, group: Annotated[str, Strict(strict=True)] | None = None, kind: Annotated[str, Strict(strict=True)], name: Annotated[str, Strict(strict=True)], namespaced: Annotated[bool, Strict(strict=True)], short_names: List[Annotated[str, Strict(strict=True)]] | None = None, singular_name: Annotated[str, Strict(strict=True)], storage_version_hash: Annotated[str, Strict(strict=True)] | None = None, verbs: List[Annotated[str, Strict(strict=True)]], version: Annotated[str, Strict(strict=True)] | None = None)

Bases: BaseModel

APIResource specifies the name of a resource and whether it is namespaced.

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.

attribute_map: ClassVar[Dict[str, str]] = {'categories': 'categories', 'group': 'group', 'kind': 'kind', 'name': 'name', 'namespaced': 'namespaced', 'short_names': 'shortNames', 'singular_name': 'singularName', 'storage_version_hash': 'storageVersionHash', 'verbs': 'verbs', 'version': 'version'}
categories: List[StrictStr] | None
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1APIResource from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1APIResource from a JSON string

group: StrictStr | None
kind: StrictStr
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: StrictStr
namespaced: StrictBool
openapi_types: ClassVar[Dict[str, str]] = {'categories': 'List[str]', 'group': 'str', 'kind': 'str', 'name': 'str', 'namespaced': 'bool', 'short_names': 'List[str]', 'singular_name': 'str', 'storage_version_hash': 'str', 'verbs': 'List[str]', 'version': 'str'}
short_names: List[StrictStr] | None
singular_name: StrictStr
storage_version_hash: StrictStr | None
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

verbs: List[StrictStr]
version: StrictStr | None
class kubernetes.client.models.V1APIResourceList(*, api_version: Annotated[str, Strict(strict=True)] | None = None, group_version: Annotated[str, Strict(strict=True)], kind: Annotated[str, Strict(strict=True)] | None = None, resources: List[V1APIResource])

Bases: BaseModel

APIResourceList is a list of APIResource, it is used to expose the name of the resources supported in a specific group and version, and if the resource is namespaced.

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.

api_version: StrictStr | None
attribute_map: ClassVar[Dict[str, str]] = {'api_version': 'apiVersion', 'group_version': 'groupVersion', 'kind': 'kind', 'resources': 'resources'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1APIResourceList from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1APIResourceList from a JSON string

group_version: StrictStr
kind: StrictStr | None
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'api_version': 'str', 'group_version': 'str', 'kind': 'str', 'resources': 'List[V1APIResource]'}
resources: List[V1APIResource]
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.V1APIService(*, api_version: Annotated[str, Strict(strict=True)] | None = None, kind: Annotated[str, Strict(strict=True)] | None = None, metadata: V1ObjectMeta | None = None, spec: V1APIServiceSpec | None = None, status: V1APIServiceStatus | None = None)

Bases: BaseModel

APIService represents a server for a particular GroupVersion. Name must be “version.group”.

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.

api_version: StrictStr | None
attribute_map: ClassVar[Dict[str, str]] = {'api_version': 'apiVersion', 'kind': 'kind', 'metadata': 'metadata', 'spec': 'spec', 'status': 'status'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1APIService from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1APIService from a JSON string

kind: StrictStr | None
metadata: V1ObjectMeta | None
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'api_version': 'str', 'kind': 'str', 'metadata': 'V1ObjectMeta', 'spec': 'V1APIServiceSpec', 'status': 'V1APIServiceStatus'}
spec: V1APIServiceSpec | None
status: V1APIServiceStatus | None
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.V1APIServiceCondition(*, last_transition_time: datetime | None = None, message: Annotated[str, Strict(strict=True)] | None = None, reason: Annotated[str, Strict(strict=True)] | None = None, status: Annotated[str, Strict(strict=True)], type: Annotated[str, Strict(strict=True)])

Bases: BaseModel

APIServiceCondition describes the state of an APIService at a particular point

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.

attribute_map: ClassVar[Dict[str, str]] = {'last_transition_time': 'lastTransitionTime', 'message': 'message', 'reason': 'reason', 'status': 'status', 'type': 'type'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1APIServiceCondition from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1APIServiceCondition from a JSON string

last_transition_time: datetime | None
message: StrictStr | None
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'last_transition_time': 'datetime', 'message': 'str', 'reason': 'str', 'status': 'str', 'type': 'str'}
reason: StrictStr | None
status: StrictStr
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

type: StrictStr
class kubernetes.client.models.V1APIServiceList(*, api_version: Annotated[str, Strict(strict=True)] | None = None, items: List[V1APIService], kind: Annotated[str, Strict(strict=True)] | None = None, metadata: V1ListMeta | None = None)

Bases: BaseModel

APIServiceList is a list of APIService objects.

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.

api_version: StrictStr | None
attribute_map: ClassVar[Dict[str, str]] = {'api_version': 'apiVersion', 'items': 'items', 'kind': 'kind', 'metadata': 'metadata'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1APIServiceList from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1APIServiceList from a JSON string

items: List[V1APIService]
kind: StrictStr | None
metadata: V1ListMeta | None
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'api_version': 'str', 'items': 'List[V1APIService]', 'kind': 'str', 'metadata': 'V1ListMeta'}
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.V1APIServiceSpec(*, ca_bundle: Annotated[bytes, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True)])] | Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True)])] | None = None, group: Annotated[str, Strict(strict=True)] | None = None, group_priority_minimum: Annotated[int, Strict(strict=True)], insecure_skip_tls_verify: Annotated[bool, Strict(strict=True)] | None = None, service: ApiregistrationV1ServiceReference | None = None, version: Annotated[str, Strict(strict=True)] | None = None, version_priority: Annotated[int, Strict(strict=True)])

Bases: BaseModel

APIServiceSpec contains information for locating and communicating with a server. Only https is supported, though you are able to disable certificate verification.

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.

attribute_map: ClassVar[Dict[str, str]] = {'ca_bundle': 'caBundle', 'group': 'group', 'group_priority_minimum': 'groupPriorityMinimum', 'insecure_skip_tls_verify': 'insecureSkipTLSVerify', 'service': 'service', 'version': 'version', 'version_priority': 'versionPriority'}
ca_bundle: Annotated[bytes, Field(strict=True)] | Annotated[str, Field(strict=True)] | None
classmethod ca_bundle_validate_regular_expression(value)

Validates the regular expression

classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1APIServiceSpec from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1APIServiceSpec from a JSON string

group: StrictStr | None
group_priority_minimum: StrictInt
insecure_skip_tls_verify: StrictBool | None
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'ca_bundle': 'bytes', 'group': 'str', 'group_priority_minimum': 'int', 'insecure_skip_tls_verify': 'bool', 'service': 'ApiregistrationV1ServiceReference', 'version': 'str', 'version_priority': 'int'}
service: ApiregistrationV1ServiceReference | None
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

version: StrictStr | None
version_priority: StrictInt
class kubernetes.client.models.V1APIServiceStatus(*, conditions: List[V1APIServiceCondition] | None = None)

Bases: BaseModel

APIServiceStatus contains derived information about an API server

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.

attribute_map: ClassVar[Dict[str, str]] = {'conditions': 'conditions'}
conditions: List[V1APIServiceCondition] | None
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1APIServiceStatus from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1APIServiceStatus from a JSON string

model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'conditions': 'List[V1APIServiceCondition]'}
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.V1APIVersions(*, api_version: Annotated[str, Strict(strict=True)] | None = None, kind: Annotated[str, Strict(strict=True)] | None = None, server_address_by_client_cidrs: List[V1ServerAddressByClientCIDR], versions: List[Annotated[str, Strict(strict=True)]])

Bases: BaseModel

APIVersions lists the versions that are available, to allow clients to discover the API at /api, which is the root path of the legacy v1 API.

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.

api_version: StrictStr | None
attribute_map: ClassVar[Dict[str, str]] = {'api_version': 'apiVersion', 'kind': 'kind', 'server_address_by_client_cidrs': 'serverAddressByClientCIDRs', 'versions': 'versions'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1APIVersions from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1APIVersions from a JSON string

kind: StrictStr | None
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'api_version': 'str', 'kind': 'str', 'server_address_by_client_cidrs': 'List[V1ServerAddressByClientCIDR]', 'versions': 'List[str]'}
server_address_by_client_cidrs: List[V1ServerAddressByClientCIDR]
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

versions: List[StrictStr]
class kubernetes.client.models.V1AWSElasticBlockStoreVolumeSource(*, fs_type: Annotated[str, Strict(strict=True)] | None = None, partition: Annotated[int, Strict(strict=True)] | None = None, read_only: Annotated[bool, Strict(strict=True)] | None = None, volume_id: Annotated[str, Strict(strict=True)])

Bases: BaseModel

Represents a Persistent Disk resource in AWS. An AWS EBS disk must exist before mounting to a container. The disk must also be in the same AWS zone as the kubelet. An AWS EBS disk can only be mounted as read/write once. AWS EBS volumes support ownership management and SELinux relabeling.

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.

attribute_map: ClassVar[Dict[str, str]] = {'fs_type': 'fsType', 'partition': 'partition', 'read_only': 'readOnly', 'volume_id': 'volumeID'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1AWSElasticBlockStoreVolumeSource from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1AWSElasticBlockStoreVolumeSource from a JSON string

fs_type: StrictStr | None
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'fs_type': 'str', 'partition': 'int', 'read_only': 'bool', 'volume_id': 'str'}
partition: StrictInt | None
read_only: StrictBool | None
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

volume_id: StrictStr
class kubernetes.client.models.V1Affinity(*, node_affinity: V1NodeAffinity | None = None, pod_affinity: V1PodAffinity | None = None, pod_anti_affinity: V1PodAntiAffinity | None = None)

Bases: BaseModel

Affinity is a group of affinity scheduling rules.

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.

attribute_map: ClassVar[Dict[str, str]] = {'node_affinity': 'nodeAffinity', 'pod_affinity': 'podAffinity', 'pod_anti_affinity': 'podAntiAffinity'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1Affinity from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1Affinity from a JSON string

model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

node_affinity: V1NodeAffinity | None
openapi_types: ClassVar[Dict[str, str]] = {'node_affinity': 'V1NodeAffinity', 'pod_affinity': 'V1PodAffinity', 'pod_anti_affinity': 'V1PodAntiAffinity'}
pod_affinity: V1PodAffinity | None
pod_anti_affinity: V1PodAntiAffinity | None
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.V1AggregationRule(*, cluster_role_selectors: List[V1LabelSelector] | None = None)

Bases: BaseModel

AggregationRule describes how to locate ClusterRoles to aggregate into the ClusterRole

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.

attribute_map: ClassVar[Dict[str, str]] = {'cluster_role_selectors': 'clusterRoleSelectors'}
cluster_role_selectors: List[V1LabelSelector] | None
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1AggregationRule from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1AggregationRule from a JSON string

model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'cluster_role_selectors': 'List[V1LabelSelector]'}
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.V1AllocatedDeviceStatus(*, conditions: List[V1Condition] | None = None, data: Dict[str, Any] | None = None, device: Annotated[str, Strict(strict=True)], driver: Annotated[str, Strict(strict=True)], network_data: V1NetworkDeviceData | None = None, pool: Annotated[str, Strict(strict=True)], share_id: Annotated[str, Strict(strict=True)] | None = None)

Bases: BaseModel

AllocatedDeviceStatus contains the status of an allocated device, if the driver chooses to report it. This may include driver-specific information. The combination of Driver, Pool, Device, and ShareID must match the corresponding key in Status.Allocation.Devices.

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.

attribute_map: ClassVar[Dict[str, str]] = {'conditions': 'conditions', 'data': 'data', 'device': 'device', 'driver': 'driver', 'network_data': 'networkData', 'pool': 'pool', 'share_id': 'shareID'}
conditions: List[V1Condition] | None
data: Dict[str, Any] | None
device: StrictStr
driver: StrictStr
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1AllocatedDeviceStatus from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1AllocatedDeviceStatus from a JSON string

model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

network_data: V1NetworkDeviceData | None
openapi_types: ClassVar[Dict[str, str]] = {'conditions': 'List[V1Condition]', 'data': 'object', 'device': 'str', 'driver': 'str', 'network_data': 'V1NetworkDeviceData', 'pool': 'str', 'share_id': 'str'}
pool: StrictStr
share_id: StrictStr | None
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.V1AllocationResult(*, allocation_timestamp: datetime | None = None, devices: V1DeviceAllocationResult | None = None, node_selector: V1NodeSelector | None = None)

Bases: BaseModel

AllocationResult contains attributes of an allocated resource.

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.

allocation_timestamp: datetime | None
attribute_map: ClassVar[Dict[str, str]] = {'allocation_timestamp': 'allocationTimestamp', 'devices': 'devices', 'node_selector': 'nodeSelector'}
devices: V1DeviceAllocationResult | None
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1AllocationResult from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1AllocationResult from a JSON string

model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

node_selector: V1NodeSelector | None
openapi_types: ClassVar[Dict[str, str]] = {'allocation_timestamp': 'datetime', 'devices': 'V1DeviceAllocationResult', 'node_selector': 'V1NodeSelector'}
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.V1AppArmorProfile(*, localhost_profile: Annotated[str, Strict(strict=True)] | None = None, type: Annotated[str, Strict(strict=True)])

Bases: BaseModel

AppArmorProfile defines a pod or container’s AppArmor settings.

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.

attribute_map: ClassVar[Dict[str, str]] = {'localhost_profile': 'localhostProfile', 'type': 'type'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1AppArmorProfile from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1AppArmorProfile from a JSON string

localhost_profile: StrictStr | None
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'localhost_profile': 'str', 'type': 'str'}
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

type: StrictStr
class kubernetes.client.models.V1ApplyConfiguration(*, expression: Annotated[str, Strict(strict=True)] | None = None)

Bases: BaseModel

ApplyConfiguration defines the desired configuration values of an object.

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.

attribute_map: ClassVar[Dict[str, str]] = {'expression': 'expression'}
expression: StrictStr | None
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1ApplyConfiguration from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1ApplyConfiguration from a JSON string

model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'expression': 'str'}
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.V1AttachedVolume(*, device_path: Annotated[str, Strict(strict=True)], name: Annotated[str, Strict(strict=True)])

Bases: BaseModel

AttachedVolume describes a volume attached to a node

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.

attribute_map: ClassVar[Dict[str, str]] = {'device_path': 'devicePath', 'name': 'name'}
device_path: StrictStr
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1AttachedVolume from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1AttachedVolume from a JSON string

model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: StrictStr
openapi_types: ClassVar[Dict[str, str]] = {'device_path': 'str', 'name': 'str'}
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.V1AuditAnnotation(*, key: Annotated[str, Strict(strict=True)], value_expression: Annotated[str, Strict(strict=True)])

Bases: BaseModel

AuditAnnotation describes how to produce an audit annotation for an API request.

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.

attribute_map: ClassVar[Dict[str, str]] = {'key': 'key', 'value_expression': 'valueExpression'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1AuditAnnotation from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1AuditAnnotation from a JSON string

key: StrictStr
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'key': 'str', 'value_expression': 'str'}
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

value_expression: StrictStr
class kubernetes.client.models.V1AzureDiskVolumeSource(*, caching_mode: Annotated[str, Strict(strict=True)] | None = None, disk_name: Annotated[str, Strict(strict=True)], disk_uri: Annotated[str, Strict(strict=True)], fs_type: Annotated[str, Strict(strict=True)] | None = None, kind: Annotated[str, Strict(strict=True)] | None = None, read_only: Annotated[bool, Strict(strict=True)] | None = None)

Bases: BaseModel

AzureDisk represents an Azure Data Disk mount on the host and bind mount to the pod.

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.

attribute_map: ClassVar[Dict[str, str]] = {'caching_mode': 'cachingMode', 'disk_name': 'diskName', 'disk_uri': 'diskURI', 'fs_type': 'fsType', 'kind': 'kind', 'read_only': 'readOnly'}
caching_mode: StrictStr | None
disk_name: StrictStr
disk_uri: StrictStr
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1AzureDiskVolumeSource from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1AzureDiskVolumeSource from a JSON string

fs_type: StrictStr | None
kind: StrictStr | None
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'caching_mode': 'str', 'disk_name': 'str', 'disk_uri': 'str', 'fs_type': 'str', 'kind': 'str', 'read_only': 'bool'}
read_only: StrictBool | None
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.V1AzureFilePersistentVolumeSource(*, read_only: Annotated[bool, Strict(strict=True)] | None = None, secret_name: Annotated[str, Strict(strict=True)], secret_namespace: Annotated[str, Strict(strict=True)] | None = None, share_name: Annotated[str, Strict(strict=True)])

Bases: BaseModel

AzureFile represents an Azure File Service mount on the host and bind mount to the pod.

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.

attribute_map: ClassVar[Dict[str, str]] = {'read_only': 'readOnly', 'secret_name': 'secretName', 'secret_namespace': 'secretNamespace', 'share_name': 'shareName'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1AzureFilePersistentVolumeSource from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1AzureFilePersistentVolumeSource from a JSON string

model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'read_only': 'bool', 'secret_name': 'str', 'secret_namespace': 'str', 'share_name': 'str'}
read_only: StrictBool | None
secret_name: StrictStr
secret_namespace: StrictStr | None
share_name: StrictStr
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.V1AzureFileVolumeSource(*, read_only: Annotated[bool, Strict(strict=True)] | None = None, secret_name: Annotated[str, Strict(strict=True)], share_name: Annotated[str, Strict(strict=True)])

Bases: BaseModel

AzureFile represents an Azure File Service mount on the host and bind mount to the pod.

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.

attribute_map: ClassVar[Dict[str, str]] = {'read_only': 'readOnly', 'secret_name': 'secretName', 'share_name': 'shareName'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1AzureFileVolumeSource from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1AzureFileVolumeSource from a JSON string

model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'read_only': 'bool', 'secret_name': 'str', 'share_name': 'str'}
read_only: StrictBool | None
secret_name: StrictStr
share_name: StrictStr
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.V1Binding(*, api_version: Annotated[str, Strict(strict=True)] | None = None, kind: Annotated[str, Strict(strict=True)] | None = None, metadata: V1ObjectMeta | None = None, target: V1ObjectReference)

Bases: BaseModel

Binding ties one object to another; for example, a pod is bound to a node by a scheduler.

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.

api_version: StrictStr | None
attribute_map: ClassVar[Dict[str, str]] = {'api_version': 'apiVersion', 'kind': 'kind', 'metadata': 'metadata', 'target': 'target'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1Binding from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1Binding from a JSON string

kind: StrictStr | None
metadata: V1ObjectMeta | None
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'api_version': 'str', 'kind': 'str', 'metadata': 'V1ObjectMeta', 'target': 'V1ObjectReference'}
target: V1ObjectReference
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.V1BoundObjectReference(*, api_version: Annotated[str, Strict(strict=True)] | None = None, kind: Annotated[str, Strict(strict=True)] | None = None, name: Annotated[str, Strict(strict=True)] | None = None, uid: Annotated[str, Strict(strict=True)] | None = None)

Bases: BaseModel

BoundObjectReference is a reference to an object that a token is bound to.

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.

api_version: StrictStr | None
attribute_map: ClassVar[Dict[str, str]] = {'api_version': 'apiVersion', 'kind': 'kind', 'name': 'name', 'uid': 'uid'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1BoundObjectReference from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1BoundObjectReference from a JSON string

kind: StrictStr | None
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: StrictStr | None
openapi_types: ClassVar[Dict[str, str]] = {'api_version': 'str', 'kind': 'str', 'name': 'str', 'uid': 'str'}
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

uid: StrictStr | None
class kubernetes.client.models.V1CELDeviceSelector(*, expression: Annotated[str, Strict(strict=True)])

Bases: BaseModel

CELDeviceSelector contains a CEL expression for selecting a device.

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.

attribute_map: ClassVar[Dict[str, str]] = {'expression': 'expression'}
expression: StrictStr
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1CELDeviceSelector from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1CELDeviceSelector from a JSON string

model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'expression': 'str'}
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.V1CSIDriver(*, api_version: Annotated[str, Strict(strict=True)] | None = None, kind: Annotated[str, Strict(strict=True)] | None = None, metadata: V1ObjectMeta | None = None, spec: V1CSIDriverSpec)

Bases: BaseModel

CSIDriver captures information about a Container Storage Interface (CSI) volume driver deployed on the cluster. Kubernetes attach detach controller uses this object to determine whether attach is required. Kubelet uses this object to determine whether pod information needs to be passed on mount. CSIDriver objects are non-namespaced.

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.

api_version: StrictStr | None
attribute_map: ClassVar[Dict[str, str]] = {'api_version': 'apiVersion', 'kind': 'kind', 'metadata': 'metadata', 'spec': 'spec'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1CSIDriver from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1CSIDriver from a JSON string

kind: StrictStr | None
metadata: V1ObjectMeta | None
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'api_version': 'str', 'kind': 'str', 'metadata': 'V1ObjectMeta', 'spec': 'V1CSIDriverSpec'}
spec: V1CSIDriverSpec
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.V1CSIDriverList(*, api_version: Annotated[str, Strict(strict=True)] | None = None, items: List[V1CSIDriver], kind: Annotated[str, Strict(strict=True)] | None = None, metadata: V1ListMeta | None = None)

Bases: BaseModel

CSIDriverList is a collection of CSIDriver objects.

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.

api_version: StrictStr | None
attribute_map: ClassVar[Dict[str, str]] = {'api_version': 'apiVersion', 'items': 'items', 'kind': 'kind', 'metadata': 'metadata'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1CSIDriverList from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1CSIDriverList from a JSON string

items: List[V1CSIDriver]
kind: StrictStr | None
metadata: V1ListMeta | None
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'api_version': 'str', 'items': 'List[V1CSIDriver]', 'kind': 'str', 'metadata': 'V1ListMeta'}
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.V1CSIDriverSpec(*, attach_required: Annotated[bool, Strict(strict=True)] | None = None, fs_group_policy: Annotated[str, Strict(strict=True)] | None = None, node_allocatable_update_period_seconds: Annotated[int, Strict(strict=True)] | None = None, pod_info_on_mount: Annotated[bool, Strict(strict=True)] | None = None, prevent_pod_scheduling_if_missing: Annotated[bool, Strict(strict=True)] | None = None, requires_republish: Annotated[bool, Strict(strict=True)] | None = None, se_linux_mount: Annotated[bool, Strict(strict=True)] | None = None, service_account_token_in_secrets: Annotated[bool, Strict(strict=True)] | None = None, storage_capacity: Annotated[bool, Strict(strict=True)] | None = None, token_requests: List[StorageV1TokenRequest] | None = None, volume_lifecycle_modes: List[Annotated[str, Strict(strict=True)]] | None = None)

Bases: BaseModel

CSIDriverSpec is the specification of a CSIDriver.

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.

attach_required: StrictBool | None
attribute_map: ClassVar[Dict[str, str]] = {'attach_required': 'attachRequired', 'fs_group_policy': 'fsGroupPolicy', 'node_allocatable_update_period_seconds': 'nodeAllocatableUpdatePeriodSeconds', 'pod_info_on_mount': 'podInfoOnMount', 'prevent_pod_scheduling_if_missing': 'preventPodSchedulingIfMissing', 'requires_republish': 'requiresRepublish', 'se_linux_mount': 'seLinuxMount', 'service_account_token_in_secrets': 'serviceAccountTokenInSecrets', 'storage_capacity': 'storageCapacity', 'token_requests': 'tokenRequests', 'volume_lifecycle_modes': 'volumeLifecycleModes'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1CSIDriverSpec from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1CSIDriverSpec from a JSON string

fs_group_policy: StrictStr | None
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

node_allocatable_update_period_seconds: StrictInt | None
openapi_types: ClassVar[Dict[str, str]] = {'attach_required': 'bool', 'fs_group_policy': 'str', 'node_allocatable_update_period_seconds': 'int', 'pod_info_on_mount': 'bool', 'prevent_pod_scheduling_if_missing': 'bool', 'requires_republish': 'bool', 'se_linux_mount': 'bool', 'service_account_token_in_secrets': 'bool', 'storage_capacity': 'bool', 'token_requests': 'List[StorageV1TokenRequest]', 'volume_lifecycle_modes': 'List[str]'}
pod_info_on_mount: StrictBool | None
prevent_pod_scheduling_if_missing: StrictBool | None
requires_republish: StrictBool | None
se_linux_mount: StrictBool | None
service_account_token_in_secrets: StrictBool | None
storage_capacity: StrictBool | None
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

token_requests: List[StorageV1TokenRequest] | None
volume_lifecycle_modes: List[StrictStr] | None
class kubernetes.client.models.V1CSINode(*, api_version: Annotated[str, Strict(strict=True)] | None = None, kind: Annotated[str, Strict(strict=True)] | None = None, metadata: V1ObjectMeta | None = None, spec: V1CSINodeSpec)

Bases: BaseModel

CSINode holds information about all CSI drivers installed on a node. CSI drivers do not need to create the CSINode object directly. As long as they use the node-driver-registrar sidecar container, the kubelet will automatically populate the CSINode object for the CSI driver as part of kubelet plugin registration. CSINode has the same name as a node. If the object is missing, it means either there are no CSI Drivers available on the node, or the Kubelet version is low enough that it doesn’t create this object. CSINode has an OwnerReference that points to the corresponding node object.

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.

api_version: StrictStr | None
attribute_map: ClassVar[Dict[str, str]] = {'api_version': 'apiVersion', 'kind': 'kind', 'metadata': 'metadata', 'spec': 'spec'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1CSINode from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1CSINode from a JSON string

kind: StrictStr | None
metadata: V1ObjectMeta | None
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'api_version': 'str', 'kind': 'str', 'metadata': 'V1ObjectMeta', 'spec': 'V1CSINodeSpec'}
spec: V1CSINodeSpec
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.V1CSINodeDriver(*, allocatable: V1VolumeNodeResources | None = None, name: Annotated[str, Strict(strict=True)], node_id: Annotated[str, Strict(strict=True)], topology_keys: List[Annotated[str, Strict(strict=True)]] | None = None)

Bases: BaseModel

CSINodeDriver holds information about the specification of one CSI driver installed on a node

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.

allocatable: V1VolumeNodeResources | None
attribute_map: ClassVar[Dict[str, str]] = {'allocatable': 'allocatable', 'name': 'name', 'node_id': 'nodeID', 'topology_keys': 'topologyKeys'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1CSINodeDriver from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1CSINodeDriver from a JSON string

model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: StrictStr
node_id: StrictStr
openapi_types: ClassVar[Dict[str, str]] = {'allocatable': 'V1VolumeNodeResources', 'name': 'str', 'node_id': 'str', 'topology_keys': 'List[str]'}
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

topology_keys: List[StrictStr] | None
class kubernetes.client.models.V1CSINodeList(*, api_version: Annotated[str, Strict(strict=True)] | None = None, items: List[V1CSINode], kind: Annotated[str, Strict(strict=True)] | None = None, metadata: V1ListMeta | None = None)

Bases: BaseModel

CSINodeList is a collection of CSINode objects.

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.

api_version: StrictStr | None
attribute_map: ClassVar[Dict[str, str]] = {'api_version': 'apiVersion', 'items': 'items', 'kind': 'kind', 'metadata': 'metadata'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1CSINodeList from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1CSINodeList from a JSON string

items: List[V1CSINode]
kind: StrictStr | None
metadata: V1ListMeta | None
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'api_version': 'str', 'items': 'List[V1CSINode]', 'kind': 'str', 'metadata': 'V1ListMeta'}
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.V1CSINodeSpec(*, drivers: List[V1CSINodeDriver])

Bases: BaseModel

CSINodeSpec holds information about the specification of all CSI drivers installed on a node

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.

attribute_map: ClassVar[Dict[str, str]] = {'drivers': 'drivers'}
drivers: List[V1CSINodeDriver]
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1CSINodeSpec from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1CSINodeSpec from a JSON string

model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'drivers': 'List[V1CSINodeDriver]'}
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.V1CSIPersistentVolumeSource(*, controller_expand_secret_ref: V1SecretReference | None = None, controller_publish_secret_ref: V1SecretReference | None = None, driver: Annotated[str, Strict(strict=True)], fs_type: Annotated[str, Strict(strict=True)] | None = None, node_expand_secret_ref: V1SecretReference | None = None, node_publish_secret_ref: V1SecretReference | None = None, node_stage_secret_ref: V1SecretReference | None = None, read_only: Annotated[bool, Strict(strict=True)] | None = None, volume_attributes: Dict[str, Annotated[str, Strict(strict=True)]] | None = None, volume_handle: Annotated[str, Strict(strict=True)])

Bases: BaseModel

Represents storage that is managed by an external CSI volume driver

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.

attribute_map: ClassVar[Dict[str, str]] = {'controller_expand_secret_ref': 'controllerExpandSecretRef', 'controller_publish_secret_ref': 'controllerPublishSecretRef', 'driver': 'driver', 'fs_type': 'fsType', 'node_expand_secret_ref': 'nodeExpandSecretRef', 'node_publish_secret_ref': 'nodePublishSecretRef', 'node_stage_secret_ref': 'nodeStageSecretRef', 'read_only': 'readOnly', 'volume_attributes': 'volumeAttributes', 'volume_handle': 'volumeHandle'}
controller_expand_secret_ref: V1SecretReference | None
controller_publish_secret_ref: V1SecretReference | None
driver: StrictStr
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1CSIPersistentVolumeSource from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1CSIPersistentVolumeSource from a JSON string

fs_type: StrictStr | None
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

node_expand_secret_ref: V1SecretReference | None
node_publish_secret_ref: V1SecretReference | None
node_stage_secret_ref: V1SecretReference | None
openapi_types: ClassVar[Dict[str, str]] = {'controller_expand_secret_ref': 'V1SecretReference', 'controller_publish_secret_ref': 'V1SecretReference', 'driver': 'str', 'fs_type': 'str', 'node_expand_secret_ref': 'V1SecretReference', 'node_publish_secret_ref': 'V1SecretReference', 'node_stage_secret_ref': 'V1SecretReference', 'read_only': 'bool', 'volume_attributes': 'Dict[str, str]', 'volume_handle': 'str'}
read_only: StrictBool | None
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

volume_attributes: Dict[str, StrictStr] | None
volume_handle: StrictStr
class kubernetes.client.models.V1CSIStorageCapacity(*, api_version: Annotated[str, Strict(strict=True)] | None = None, capacity: Annotated[str, Strict(strict=True)] | None = None, kind: Annotated[str, Strict(strict=True)] | None = None, maximum_volume_size: Annotated[str, Strict(strict=True)] | None = None, metadata: V1ObjectMeta | None = None, node_topology: V1LabelSelector | None = None, storage_class_name: Annotated[str, Strict(strict=True)])

Bases: BaseModel

CSIStorageCapacity stores the result of one CSI GetCapacity call. For a given StorageClass, this describes the available capacity in a particular topology segment. This can be used when considering where to instantiate new PersistentVolumes. For example this can express things like: - StorageClass “standard” has “1234 GiB” available in “topology.kubernetes.io/zone=us-east1” - StorageClass “localssd” has “10 GiB” available in “kubernetes.io/hostname=knode-abc123” The following three cases all imply that no capacity is available for a certain combination: - no object exists with suitable topology and storage class name - such an object exists, but the capacity is unset - such an object exists, but the capacity is zero The producer of these objects can decide which approach is more suitable. They are consumed by the kube-scheduler when a CSI driver opts into capacity-aware scheduling with CSIDriverSpec.StorageCapacity. The scheduler compares the MaximumVolumeSize against the requested size of pending volumes to filter out unsuitable nodes. If MaximumVolumeSize is unset, it falls back to a comparison against the less precise Capacity. If that is also unset, the scheduler assumes that capacity is insufficient and tries some other node.

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.

api_version: StrictStr | None
attribute_map: ClassVar[Dict[str, str]] = {'api_version': 'apiVersion', 'capacity': 'capacity', 'kind': 'kind', 'maximum_volume_size': 'maximumVolumeSize', 'metadata': 'metadata', 'node_topology': 'nodeTopology', 'storage_class_name': 'storageClassName'}
capacity: StrictStr | None
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1CSIStorageCapacity from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1CSIStorageCapacity from a JSON string

kind: StrictStr | None
maximum_volume_size: StrictStr | None
metadata: V1ObjectMeta | None
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

node_topology: V1LabelSelector | None
openapi_types: ClassVar[Dict[str, str]] = {'api_version': 'str', 'capacity': 'str', 'kind': 'str', 'maximum_volume_size': 'str', 'metadata': 'V1ObjectMeta', 'node_topology': 'V1LabelSelector', 'storage_class_name': 'str'}
storage_class_name: StrictStr
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.V1CSIStorageCapacityList(*, api_version: Annotated[str, Strict(strict=True)] | None = None, items: List[V1CSIStorageCapacity], kind: Annotated[str, Strict(strict=True)] | None = None, metadata: V1ListMeta | None = None)

Bases: BaseModel

CSIStorageCapacityList is a collection of CSIStorageCapacity objects.

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.

api_version: StrictStr | None
attribute_map: ClassVar[Dict[str, str]] = {'api_version': 'apiVersion', 'items': 'items', 'kind': 'kind', 'metadata': 'metadata'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1CSIStorageCapacityList from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1CSIStorageCapacityList from a JSON string

items: List[V1CSIStorageCapacity]
kind: StrictStr | None
metadata: V1ListMeta | None
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'api_version': 'str', 'items': 'List[V1CSIStorageCapacity]', 'kind': 'str', 'metadata': 'V1ListMeta'}
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.V1CSIVolumeSource(*, driver: Annotated[str, Strict(strict=True)], fs_type: Annotated[str, Strict(strict=True)] | None = None, node_publish_secret_ref: V1LocalObjectReference | None = None, read_only: Annotated[bool, Strict(strict=True)] | None = None, volume_attributes: Dict[str, Annotated[str, Strict(strict=True)]] | None = None)

Bases: BaseModel

Represents a source location of a volume to mount, managed by an external CSI driver

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.

attribute_map: ClassVar[Dict[str, str]] = {'driver': 'driver', 'fs_type': 'fsType', 'node_publish_secret_ref': 'nodePublishSecretRef', 'read_only': 'readOnly', 'volume_attributes': 'volumeAttributes'}
driver: StrictStr
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1CSIVolumeSource from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1CSIVolumeSource from a JSON string

fs_type: StrictStr | None
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

node_publish_secret_ref: V1LocalObjectReference | None
openapi_types: ClassVar[Dict[str, str]] = {'driver': 'str', 'fs_type': 'str', 'node_publish_secret_ref': 'V1LocalObjectReference', 'read_only': 'bool', 'volume_attributes': 'Dict[str, str]'}
read_only: StrictBool | None
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

volume_attributes: Dict[str, StrictStr] | None
class kubernetes.client.models.V1Capabilities(*, add: List[Annotated[str, Strict(strict=True)]] | None = None, drop: List[Annotated[str, Strict(strict=True)]] | None = None)

Bases: BaseModel

Adds and removes POSIX capabilities from running containers.

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.

add: List[StrictStr] | None
attribute_map: ClassVar[Dict[str, str]] = {'add': 'add', 'drop': 'drop'}
drop: List[StrictStr] | None
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1Capabilities from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1Capabilities from a JSON string

model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'add': 'List[str]', 'drop': 'List[str]'}
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.V1CapacityRequestPolicy(*, default: Annotated[str, Strict(strict=True)] | None = None, valid_range: V1CapacityRequestPolicyRange | None = None, valid_values: List[Annotated[str, Strict(strict=True)]] | None = None)

Bases: BaseModel

CapacityRequestPolicy defines how requests consume device capacity. Must not set more than one ValidRequestValues.

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.

attribute_map: ClassVar[Dict[str, str]] = {'default': 'default', 'valid_range': 'validRange', 'valid_values': 'validValues'}
default: StrictStr | None
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1CapacityRequestPolicy from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1CapacityRequestPolicy from a JSON string

model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'default': 'str', 'valid_range': 'V1CapacityRequestPolicyRange', 'valid_values': 'List[str]'}
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

valid_range: V1CapacityRequestPolicyRange | None
valid_values: List[StrictStr] | None
class kubernetes.client.models.V1CapacityRequestPolicyRange(*, max: Annotated[str, Strict(strict=True)] | None = None, min: Annotated[str, Strict(strict=True)], step: Annotated[str, Strict(strict=True)] | None = None)

Bases: BaseModel

CapacityRequestPolicyRange defines a valid range for consumable capacity values. - If the requested amount is less than Min, it is rounded up to the Min value. - If Step is set and the requested amount is between Min and Max but not aligned with Step, it will be rounded up to the next value equal to Min + (n * Step). - If Step is not set, the requested amount is used as-is if it falls within the range Min to Max (if set). - If the requested or rounded amount exceeds Max (if set), the request does not satisfy the policy, and the device cannot be allocated.

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.

attribute_map: ClassVar[Dict[str, str]] = {'max': 'max', 'min': 'min', 'step': 'step'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1CapacityRequestPolicyRange from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1CapacityRequestPolicyRange from a JSON string

max: StrictStr | None
min: StrictStr
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'max': 'str', 'min': 'str', 'step': 'str'}
step: StrictStr | None
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.V1CapacityRequirements(*, requests: Dict[str, Annotated[str, Strict(strict=True)]] | None = None)

Bases: BaseModel

CapacityRequirements defines the capacity requirements for a specific device request.

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.

attribute_map: ClassVar[Dict[str, str]] = {'requests': 'requests'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1CapacityRequirements from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1CapacityRequirements from a JSON string

model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'requests': 'Dict[str, str]'}
requests: Dict[str, StrictStr] | None
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.V1CephFSPersistentVolumeSource(*, monitors: List[Annotated[str, Strict(strict=True)]], path: Annotated[str, Strict(strict=True)] | None = None, read_only: Annotated[bool, Strict(strict=True)] | None = None, secret_file: Annotated[str, Strict(strict=True)] | None = None, secret_ref: V1SecretReference | None = None, user: Annotated[str, Strict(strict=True)] | None = None)

Bases: BaseModel

Represents a Ceph Filesystem mount that lasts the lifetime of a pod Cephfs volumes do not support ownership management or SELinux relabeling.

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.

attribute_map: ClassVar[Dict[str, str]] = {'monitors': 'monitors', 'path': 'path', 'read_only': 'readOnly', 'secret_file': 'secretFile', 'secret_ref': 'secretRef', 'user': 'user'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1CephFSPersistentVolumeSource from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1CephFSPersistentVolumeSource from a JSON string

model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

monitors: List[StrictStr]
openapi_types: ClassVar[Dict[str, str]] = {'monitors': 'List[str]', 'path': 'str', 'read_only': 'bool', 'secret_file': 'str', 'secret_ref': 'V1SecretReference', 'user': 'str'}
path: StrictStr | None
read_only: StrictBool | None
secret_file: StrictStr | None
secret_ref: V1SecretReference | None
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

user: StrictStr | None
class kubernetes.client.models.V1CephFSVolumeSource(*, monitors: List[Annotated[str, Strict(strict=True)]], path: Annotated[str, Strict(strict=True)] | None = None, read_only: Annotated[bool, Strict(strict=True)] | None = None, secret_file: Annotated[str, Strict(strict=True)] | None = None, secret_ref: V1LocalObjectReference | None = None, user: Annotated[str, Strict(strict=True)] | None = None)

Bases: BaseModel

Represents a Ceph Filesystem mount that lasts the lifetime of a pod Cephfs volumes do not support ownership management or SELinux relabeling.

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.

attribute_map: ClassVar[Dict[str, str]] = {'monitors': 'monitors', 'path': 'path', 'read_only': 'readOnly', 'secret_file': 'secretFile', 'secret_ref': 'secretRef', 'user': 'user'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1CephFSVolumeSource from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1CephFSVolumeSource from a JSON string

model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

monitors: List[StrictStr]
openapi_types: ClassVar[Dict[str, str]] = {'monitors': 'List[str]', 'path': 'str', 'read_only': 'bool', 'secret_file': 'str', 'secret_ref': 'V1LocalObjectReference', 'user': 'str'}
path: StrictStr | None
read_only: StrictBool | None
secret_file: StrictStr | None
secret_ref: V1LocalObjectReference | None
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

user: StrictStr | None
class kubernetes.client.models.V1CertificateSigningRequest(*, api_version: Annotated[str, Strict(strict=True)] | None = None, kind: Annotated[str, Strict(strict=True)] | None = None, metadata: V1ObjectMeta | None = None, spec: V1CertificateSigningRequestSpec, status: V1CertificateSigningRequestStatus | None = None)

Bases: BaseModel

CertificateSigningRequest objects provide a mechanism to obtain x509 certificates by submitting a certificate signing request, and having it asynchronously approved and issued. Kubelets use this API to obtain: 1. client certificates to authenticate to kube-apiserver (with the “kubernetes.io/kube-apiserver-client-kubelet” signerName). 2. serving certificates for TLS endpoints kube-apiserver can connect to securely (with the “kubernetes.io/kubelet-serving” signerName). This API can be used to request client certificates to authenticate to kube-apiserver (with the “kubernetes.io/kube-apiserver-client” signerName), or to obtain certificates from custom non-Kubernetes signers.

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.

api_version: StrictStr | None
attribute_map: ClassVar[Dict[str, str]] = {'api_version': 'apiVersion', 'kind': 'kind', 'metadata': 'metadata', 'spec': 'spec', 'status': 'status'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1CertificateSigningRequest from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1CertificateSigningRequest from a JSON string

kind: StrictStr | None
metadata: V1ObjectMeta | None
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'api_version': 'str', 'kind': 'str', 'metadata': 'V1ObjectMeta', 'spec': 'V1CertificateSigningRequestSpec', 'status': 'V1CertificateSigningRequestStatus'}
spec: V1CertificateSigningRequestSpec
status: V1CertificateSigningRequestStatus | None
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.V1CertificateSigningRequestCondition(*, last_transition_time: datetime | None = None, last_update_time: datetime | None = None, message: Annotated[str, Strict(strict=True)] | None = None, reason: Annotated[str, Strict(strict=True)] | None = None, status: Annotated[str, Strict(strict=True)], type: Annotated[str, Strict(strict=True)])

Bases: BaseModel

CertificateSigningRequestCondition describes a condition of a CertificateSigningRequest object

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.

attribute_map: ClassVar[Dict[str, str]] = {'last_transition_time': 'lastTransitionTime', 'last_update_time': 'lastUpdateTime', 'message': 'message', 'reason': 'reason', 'status': 'status', 'type': 'type'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1CertificateSigningRequestCondition from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1CertificateSigningRequestCondition from a JSON string

last_transition_time: datetime | None
last_update_time: datetime | None
message: StrictStr | None
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'last_transition_time': 'datetime', 'last_update_time': 'datetime', 'message': 'str', 'reason': 'str', 'status': 'str', 'type': 'str'}
reason: StrictStr | None
status: StrictStr
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

type: StrictStr
class kubernetes.client.models.V1CertificateSigningRequestList(*, api_version: Annotated[str, Strict(strict=True)] | None = None, items: List[V1CertificateSigningRequest], kind: Annotated[str, Strict(strict=True)] | None = None, metadata: V1ListMeta | None = None)

Bases: BaseModel

CertificateSigningRequestList is a collection of CertificateSigningRequest objects

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.

api_version: StrictStr | None
attribute_map: ClassVar[Dict[str, str]] = {'api_version': 'apiVersion', 'items': 'items', 'kind': 'kind', 'metadata': 'metadata'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1CertificateSigningRequestList from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1CertificateSigningRequestList from a JSON string

items: List[V1CertificateSigningRequest]
kind: StrictStr | None
metadata: V1ListMeta | None
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'api_version': 'str', 'items': 'List[V1CertificateSigningRequest]', 'kind': 'str', 'metadata': 'V1ListMeta'}
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.V1CertificateSigningRequestSpec(*, expiration_seconds: Annotated[int, Strict(strict=True)] | None = None, extra: Dict[str, List[Annotated[str, Strict(strict=True)]]] | None = None, groups: List[Annotated[str, Strict(strict=True)]] | None = None, request: Annotated[bytes, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True)])] | Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True)])], signer_name: Annotated[str, Strict(strict=True)], uid: Annotated[str, Strict(strict=True)] | None = None, usages: List[Annotated[str, Strict(strict=True)]] | None = None, username: Annotated[str, Strict(strict=True)] | None = None)

Bases: BaseModel

CertificateSigningRequestSpec contains the certificate request.

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.

attribute_map: ClassVar[Dict[str, str]] = {'expiration_seconds': 'expirationSeconds', 'extra': 'extra', 'groups': 'groups', 'request': 'request', 'signer_name': 'signerName', 'uid': 'uid', 'usages': 'usages', 'username': 'username'}
expiration_seconds: StrictInt | None
extra: Dict[str, List[StrictStr]] | None
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1CertificateSigningRequestSpec from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1CertificateSigningRequestSpec from a JSON string

groups: List[StrictStr] | None
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'expiration_seconds': 'int', 'extra': 'Dict[str, List[str]]', 'groups': 'List[str]', 'request': 'bytes', 'signer_name': 'str', 'uid': 'str', 'usages': 'List[str]', 'username': 'str'}
request: Annotated[bytes, Field(strict=True)] | Annotated[str, Field(strict=True)]
classmethod request_validate_regular_expression(value)

Validates the regular expression

signer_name: StrictStr
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

uid: StrictStr | None
usages: List[StrictStr] | None
username: StrictStr | None
class kubernetes.client.models.V1CertificateSigningRequestStatus(*, certificate: Annotated[bytes, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True)])] | Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True)])] | None = None, conditions: List[V1CertificateSigningRequestCondition] | None = None)

Bases: BaseModel

CertificateSigningRequestStatus contains conditions used to indicate approved/denied/failed status of the request, and the issued certificate.

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.

attribute_map: ClassVar[Dict[str, str]] = {'certificate': 'certificate', 'conditions': 'conditions'}
certificate: Annotated[bytes, Field(strict=True)] | Annotated[str, Field(strict=True)] | None
classmethod certificate_validate_regular_expression(value)

Validates the regular expression

conditions: List[V1CertificateSigningRequestCondition] | None
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1CertificateSigningRequestStatus from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1CertificateSigningRequestStatus from a JSON string

model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'certificate': 'bytes', 'conditions': 'List[V1CertificateSigningRequestCondition]'}
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.V1CinderPersistentVolumeSource(*, fs_type: Annotated[str, Strict(strict=True)] | None = None, read_only: Annotated[bool, Strict(strict=True)] | None = None, secret_ref: V1SecretReference | None = None, volume_id: Annotated[str, Strict(strict=True)])

Bases: BaseModel

Represents a cinder volume resource in Openstack. A Cinder volume must exist before mounting to a container. The volume must also be in the same region as the kubelet. Cinder volumes support ownership management and SELinux relabeling.

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.

attribute_map: ClassVar[Dict[str, str]] = {'fs_type': 'fsType', 'read_only': 'readOnly', 'secret_ref': 'secretRef', 'volume_id': 'volumeID'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1CinderPersistentVolumeSource from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1CinderPersistentVolumeSource from a JSON string

fs_type: StrictStr | None
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'fs_type': 'str', 'read_only': 'bool', 'secret_ref': 'V1SecretReference', 'volume_id': 'str'}
read_only: StrictBool | None
secret_ref: V1SecretReference | None
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

volume_id: StrictStr
class kubernetes.client.models.V1CinderVolumeSource(*, fs_type: Annotated[str, Strict(strict=True)] | None = None, read_only: Annotated[bool, Strict(strict=True)] | None = None, secret_ref: V1LocalObjectReference | None = None, volume_id: Annotated[str, Strict(strict=True)])

Bases: BaseModel

Represents a cinder volume resource in Openstack. A Cinder volume must exist before mounting to a container. The volume must also be in the same region as the kubelet. Cinder volumes support ownership management and SELinux relabeling.

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.

attribute_map: ClassVar[Dict[str, str]] = {'fs_type': 'fsType', 'read_only': 'readOnly', 'secret_ref': 'secretRef', 'volume_id': 'volumeID'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1CinderVolumeSource from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1CinderVolumeSource from a JSON string

fs_type: StrictStr | None
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'fs_type': 'str', 'read_only': 'bool', 'secret_ref': 'V1LocalObjectReference', 'volume_id': 'str'}
read_only: StrictBool | None
secret_ref: V1LocalObjectReference | None
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

volume_id: StrictStr
class kubernetes.client.models.V1ClientIPConfig(*, timeout_seconds: Annotated[int, Strict(strict=True)] | None = None)

Bases: BaseModel

ClientIPConfig represents the configurations of Client IP based session affinity.

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.

attribute_map: ClassVar[Dict[str, str]] = {'timeout_seconds': 'timeoutSeconds'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1ClientIPConfig from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1ClientIPConfig from a JSON string

model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'timeout_seconds': 'int'}
timeout_seconds: StrictInt | None
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.V1ClusterRole(*, aggregation_rule: V1AggregationRule | None = None, api_version: Annotated[str, Strict(strict=True)] | None = None, kind: Annotated[str, Strict(strict=True)] | None = None, metadata: V1ObjectMeta | None = None, rules: List[V1PolicyRule] | None = None)

Bases: BaseModel

ClusterRole is a cluster level, logical grouping of PolicyRules that can be referenced as a unit by a RoleBinding or ClusterRoleBinding.

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.

aggregation_rule: V1AggregationRule | None
api_version: StrictStr | None
attribute_map: ClassVar[Dict[str, str]] = {'aggregation_rule': 'aggregationRule', 'api_version': 'apiVersion', 'kind': 'kind', 'metadata': 'metadata', 'rules': 'rules'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1ClusterRole from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1ClusterRole from a JSON string

kind: StrictStr | None
metadata: V1ObjectMeta | None
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'aggregation_rule': 'V1AggregationRule', 'api_version': 'str', 'kind': 'str', 'metadata': 'V1ObjectMeta', 'rules': 'List[V1PolicyRule]'}
rules: List[V1PolicyRule] | None
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.V1ClusterRoleBinding(*, api_version: Annotated[str, Strict(strict=True)] | None = None, kind: Annotated[str, Strict(strict=True)] | None = None, metadata: V1ObjectMeta | None = None, role_ref: V1RoleRef, subjects: List[RbacV1Subject] | None = None)

Bases: BaseModel

ClusterRoleBinding references a ClusterRole, but not contain it. It can reference a ClusterRole in the global namespace, and adds who information via Subject.

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.

api_version: StrictStr | None
attribute_map: ClassVar[Dict[str, str]] = {'api_version': 'apiVersion', 'kind': 'kind', 'metadata': 'metadata', 'role_ref': 'roleRef', 'subjects': 'subjects'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1ClusterRoleBinding from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1ClusterRoleBinding from a JSON string

kind: StrictStr | None
metadata: V1ObjectMeta | None
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'api_version': 'str', 'kind': 'str', 'metadata': 'V1ObjectMeta', 'role_ref': 'V1RoleRef', 'subjects': 'List[RbacV1Subject]'}
role_ref: V1RoleRef
subjects: List[RbacV1Subject] | None
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.V1ClusterRoleBindingList(*, api_version: Annotated[str, Strict(strict=True)] | None = None, items: List[V1ClusterRoleBinding], kind: Annotated[str, Strict(strict=True)] | None = None, metadata: V1ListMeta | None = None)

Bases: BaseModel

ClusterRoleBindingList is a collection of ClusterRoleBindings

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.

api_version: StrictStr | None
attribute_map: ClassVar[Dict[str, str]] = {'api_version': 'apiVersion', 'items': 'items', 'kind': 'kind', 'metadata': 'metadata'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1ClusterRoleBindingList from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1ClusterRoleBindingList from a JSON string

items: List[V1ClusterRoleBinding]
kind: StrictStr | None
metadata: V1ListMeta | None
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'api_version': 'str', 'items': 'List[V1ClusterRoleBinding]', 'kind': 'str', 'metadata': 'V1ListMeta'}
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.V1ClusterRoleList(*, api_version: Annotated[str, Strict(strict=True)] | None = None, items: List[V1ClusterRole], kind: Annotated[str, Strict(strict=True)] | None = None, metadata: V1ListMeta | None = None)

Bases: BaseModel

ClusterRoleList is a collection of ClusterRoles

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.

api_version: StrictStr | None
attribute_map: ClassVar[Dict[str, str]] = {'api_version': 'apiVersion', 'items': 'items', 'kind': 'kind', 'metadata': 'metadata'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1ClusterRoleList from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1ClusterRoleList from a JSON string

items: List[V1ClusterRole]
kind: StrictStr | None
metadata: V1ListMeta | None
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'api_version': 'str', 'items': 'List[V1ClusterRole]', 'kind': 'str', 'metadata': 'V1ListMeta'}
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.V1ClusterTrustBundleProjection(*, label_selector: V1LabelSelector | None = None, name: Annotated[str, Strict(strict=True)] | None = None, optional: Annotated[bool, Strict(strict=True)] | None = None, path: Annotated[str, Strict(strict=True)], signer_name: Annotated[str, Strict(strict=True)] | None = None)

Bases: BaseModel

ClusterTrustBundleProjection describes how to select a set of ClusterTrustBundle objects and project their contents into the pod filesystem.

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.

attribute_map: ClassVar[Dict[str, str]] = {'label_selector': 'labelSelector', 'name': 'name', 'optional': 'optional', 'path': 'path', 'signer_name': 'signerName'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1ClusterTrustBundleProjection from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1ClusterTrustBundleProjection from a JSON string

label_selector: V1LabelSelector | None
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: StrictStr | None
openapi_types: ClassVar[Dict[str, str]] = {'label_selector': 'V1LabelSelector', 'name': 'str', 'optional': 'bool', 'path': 'str', 'signer_name': 'str'}
optional: StrictBool | None
path: StrictStr
signer_name: StrictStr | None
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.V1ComponentCondition(*, error: Annotated[str, Strict(strict=True)] | None = None, message: Annotated[str, Strict(strict=True)] | None = None, status: Annotated[str, Strict(strict=True)], type: Annotated[str, Strict(strict=True)])

Bases: BaseModel

Information about the condition of a component.

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.

attribute_map: ClassVar[Dict[str, str]] = {'error': 'error', 'message': 'message', 'status': 'status', 'type': 'type'}
error: StrictStr | None
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1ComponentCondition from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1ComponentCondition from a JSON string

message: StrictStr | None
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'error': 'str', 'message': 'str', 'status': 'str', 'type': 'str'}
status: StrictStr
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

type: StrictStr
class kubernetes.client.models.V1ComponentStatus(*, api_version: Annotated[str, Strict(strict=True)] | None = None, conditions: List[V1ComponentCondition] | None = None, kind: Annotated[str, Strict(strict=True)] | None = None, metadata: V1ObjectMeta | None = None)

Bases: BaseModel

ComponentStatus (and ComponentStatusList) holds the cluster validation info. Deprecated: This API is deprecated in v1.19+

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.

api_version: StrictStr | None
attribute_map: ClassVar[Dict[str, str]] = {'api_version': 'apiVersion', 'conditions': 'conditions', 'kind': 'kind', 'metadata': 'metadata'}
conditions: List[V1ComponentCondition] | None
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1ComponentStatus from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1ComponentStatus from a JSON string

kind: StrictStr | None
metadata: V1ObjectMeta | None
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'api_version': 'str', 'conditions': 'List[V1ComponentCondition]', 'kind': 'str', 'metadata': 'V1ObjectMeta'}
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.V1ComponentStatusList(*, api_version: Annotated[str, Strict(strict=True)] | None = None, items: List[V1ComponentStatus], kind: Annotated[str, Strict(strict=True)] | None = None, metadata: V1ListMeta | None = None)

Bases: BaseModel

Status of all the conditions for the component as a list of ComponentStatus objects. Deprecated: This API is deprecated in v1.19+

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.

api_version: StrictStr | None
attribute_map: ClassVar[Dict[str, str]] = {'api_version': 'apiVersion', 'items': 'items', 'kind': 'kind', 'metadata': 'metadata'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1ComponentStatusList from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1ComponentStatusList from a JSON string

items: List[V1ComponentStatus]
kind: StrictStr | None
metadata: V1ListMeta | None
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'api_version': 'str', 'items': 'List[V1ComponentStatus]', 'kind': 'str', 'metadata': 'V1ListMeta'}
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.V1Condition(*, last_transition_time: datetime, message: Annotated[str, Strict(strict=True)], observed_generation: Annotated[int, Strict(strict=True)] | None = None, reason: Annotated[str, Strict(strict=True)], status: Annotated[str, Strict(strict=True)], type: Annotated[str, Strict(strict=True)])

Bases: BaseModel

Condition contains details for one aspect of the current state of this API Resource.

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.

attribute_map: ClassVar[Dict[str, str]] = {'last_transition_time': 'lastTransitionTime', 'message': 'message', 'observed_generation': 'observedGeneration', 'reason': 'reason', 'status': 'status', 'type': 'type'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1Condition from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1Condition from a JSON string

last_transition_time: datetime
message: StrictStr
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

observed_generation: StrictInt | None
openapi_types: ClassVar[Dict[str, str]] = {'last_transition_time': 'datetime', 'message': 'str', 'observed_generation': 'int', 'reason': 'str', 'status': 'str', 'type': 'str'}
reason: StrictStr
status: StrictStr
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

type: StrictStr
class kubernetes.client.models.V1ConfigMap(*, api_version: Annotated[str, Strict(strict=True)] | None = None, binary_data: Dict[str, Annotated[bytes, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True)])] | Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True)])]] | None = None, data: Dict[str, Annotated[str, Strict(strict=True)]] | None = None, immutable: Annotated[bool, Strict(strict=True)] | None = None, kind: Annotated[str, Strict(strict=True)] | None = None, metadata: V1ObjectMeta | None = None)

Bases: BaseModel

ConfigMap holds configuration data for pods to consume.

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.

api_version: StrictStr | None
attribute_map: ClassVar[Dict[str, str]] = {'api_version': 'apiVersion', 'binary_data': 'binaryData', 'data': 'data', 'immutable': 'immutable', 'kind': 'kind', 'metadata': 'metadata'}
binary_data: Dict[str, Annotated[bytes, Field(strict=True)] | Annotated[str, Field(strict=True)]] | None
data: Dict[str, StrictStr] | None
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1ConfigMap from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1ConfigMap from a JSON string

immutable: StrictBool | None
kind: StrictStr | None
metadata: V1ObjectMeta | None
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'api_version': 'str', 'binary_data': 'Dict[str, bytes]', 'data': 'Dict[str, str]', 'immutable': 'bool', 'kind': 'str', 'metadata': 'V1ObjectMeta'}
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.V1ConfigMapEnvSource(*, name: Annotated[str, Strict(strict=True)] | None = None, optional: Annotated[bool, Strict(strict=True)] | None = None)

Bases: BaseModel

ConfigMapEnvSource selects a ConfigMap to populate the environment variables with. The contents of the target ConfigMap’s Data field will represent the key-value pairs as environment variables.

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.

attribute_map: ClassVar[Dict[str, str]] = {'name': 'name', 'optional': 'optional'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1ConfigMapEnvSource from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1ConfigMapEnvSource from a JSON string

model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: StrictStr | None
openapi_types: ClassVar[Dict[str, str]] = {'name': 'str', 'optional': 'bool'}
optional: StrictBool | None
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.V1ConfigMapKeySelector(*, key: Annotated[str, Strict(strict=True)], name: Annotated[str, Strict(strict=True)] | None = None, optional: Annotated[bool, Strict(strict=True)] | None = None)

Bases: BaseModel

Selects a key from a ConfigMap.

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.

attribute_map: ClassVar[Dict[str, str]] = {'key': 'key', 'name': 'name', 'optional': 'optional'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1ConfigMapKeySelector from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1ConfigMapKeySelector from a JSON string

key: StrictStr
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: StrictStr | None
openapi_types: ClassVar[Dict[str, str]] = {'key': 'str', 'name': 'str', 'optional': 'bool'}
optional: StrictBool | None
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.V1ConfigMapList(*, api_version: Annotated[str, Strict(strict=True)] | None = None, items: List[V1ConfigMap], kind: Annotated[str, Strict(strict=True)] | None = None, metadata: V1ListMeta | None = None)

Bases: BaseModel

ConfigMapList is a resource containing a list of ConfigMap objects.

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.

api_version: StrictStr | None
attribute_map: ClassVar[Dict[str, str]] = {'api_version': 'apiVersion', 'items': 'items', 'kind': 'kind', 'metadata': 'metadata'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1ConfigMapList from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1ConfigMapList from a JSON string

items: List[V1ConfigMap]
kind: StrictStr | None
metadata: V1ListMeta | None
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'api_version': 'str', 'items': 'List[V1ConfigMap]', 'kind': 'str', 'metadata': 'V1ListMeta'}
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.V1ConfigMapNodeConfigSource(*, kubelet_config_key: Annotated[str, Strict(strict=True)], name: Annotated[str, Strict(strict=True)], namespace: Annotated[str, Strict(strict=True)], resource_version: Annotated[str, Strict(strict=True)] | None = None, uid: Annotated[str, Strict(strict=True)] | None = None)

Bases: BaseModel

ConfigMapNodeConfigSource contains the information to reference a ConfigMap as a config source for the Node. This API is deprecated since 1.22: https://git.k8s.io/enhancements/keps/sig-node/281-dynamic-kubelet-configuration

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.

attribute_map: ClassVar[Dict[str, str]] = {'kubelet_config_key': 'kubeletConfigKey', 'name': 'name', 'namespace': 'namespace', 'resource_version': 'resourceVersion', 'uid': 'uid'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1ConfigMapNodeConfigSource from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1ConfigMapNodeConfigSource from a JSON string

kubelet_config_key: StrictStr
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: StrictStr
namespace: StrictStr
openapi_types: ClassVar[Dict[str, str]] = {'kubelet_config_key': 'str', 'name': 'str', 'namespace': 'str', 'resource_version': 'str', 'uid': 'str'}
resource_version: StrictStr | None
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

uid: StrictStr | None
class kubernetes.client.models.V1ConfigMapProjection(*, items: List[V1KeyToPath] | None = None, name: Annotated[str, Strict(strict=True)] | None = None, optional: Annotated[bool, Strict(strict=True)] | None = None)

Bases: BaseModel

Adapts a ConfigMap into a projected volume. The contents of the target ConfigMap’s Data field will be presented in a projected volume as files using the keys in the Data field as the file names, unless the items element is populated with specific mappings of keys to paths. Note that this is identical to a configmap volume source without the default mode.

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.

attribute_map: ClassVar[Dict[str, str]] = {'items': 'items', 'name': 'name', 'optional': 'optional'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1ConfigMapProjection from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1ConfigMapProjection from a JSON string

items: List[V1KeyToPath] | None
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: StrictStr | None
openapi_types: ClassVar[Dict[str, str]] = {'items': 'List[V1KeyToPath]', 'name': 'str', 'optional': 'bool'}
optional: StrictBool | None
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.V1ConfigMapVolumeSource(*, default_mode: Annotated[int, Strict(strict=True)] | None = None, items: List[V1KeyToPath] | None = None, name: Annotated[str, Strict(strict=True)] | None = None, optional: Annotated[bool, Strict(strict=True)] | None = None)

Bases: BaseModel

Adapts a ConfigMap into a volume. The contents of the target ConfigMap’s Data field will be presented in a volume as files using the keys in the Data field as the file names, unless the items element is populated with specific mappings of keys to paths. ConfigMap volumes support ownership management and SELinux relabeling.

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.

attribute_map: ClassVar[Dict[str, str]] = {'default_mode': 'defaultMode', 'items': 'items', 'name': 'name', 'optional': 'optional'}
default_mode: StrictInt | None
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1ConfigMapVolumeSource from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1ConfigMapVolumeSource from a JSON string

items: List[V1KeyToPath] | None
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: StrictStr | None
openapi_types: ClassVar[Dict[str, str]] = {'default_mode': 'int', 'items': 'List[V1KeyToPath]', 'name': 'str', 'optional': 'bool'}
optional: StrictBool | None
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.V1Container(*, args: List[Annotated[str, Strict(strict=True)]] | None = None, command: List[Annotated[str, Strict(strict=True)]] | None = None, env: List[V1EnvVar] | None = None, env_from: List[V1EnvFromSource] | None = None, image: Annotated[str, Strict(strict=True)] | None = None, image_pull_policy: Annotated[str, Strict(strict=True)] | None = None, lifecycle: V1Lifecycle | None = None, liveness_probe: V1Probe | None = None, name: Annotated[str, Strict(strict=True)], ports: List[V1ContainerPort] | None = None, readiness_probe: V1Probe | None = None, resize_policy: List[V1ContainerResizePolicy] | None = None, resources: V1ResourceRequirements | None = None, restart_policy: Annotated[str, Strict(strict=True)] | None = None, restart_policy_rules: List[V1ContainerRestartRule] | None = None, security_context: V1SecurityContext | None = None, startup_probe: V1Probe | None = None, stdin: Annotated[bool, Strict(strict=True)] | None = None, stdin_once: Annotated[bool, Strict(strict=True)] | None = None, termination_message_path: Annotated[str, Strict(strict=True)] | None = None, termination_message_policy: Annotated[str, Strict(strict=True)] | None = None, tty: Annotated[bool, Strict(strict=True)] | None = None, volume_devices: List[V1VolumeDevice] | None = None, volume_mounts: List[V1VolumeMount] | None = None, working_dir: Annotated[str, Strict(strict=True)] | None = None)

Bases: BaseModel

A single application container that you want to run within a pod.

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.

args: List[StrictStr] | None
attribute_map: ClassVar[Dict[str, str]] = {'args': 'args', 'command': 'command', 'env': 'env', 'env_from': 'envFrom', 'image': 'image', 'image_pull_policy': 'imagePullPolicy', 'lifecycle': 'lifecycle', 'liveness_probe': 'livenessProbe', 'name': 'name', 'ports': 'ports', 'readiness_probe': 'readinessProbe', 'resize_policy': 'resizePolicy', 'resources': 'resources', 'restart_policy': 'restartPolicy', 'restart_policy_rules': 'restartPolicyRules', 'security_context': 'securityContext', 'startup_probe': 'startupProbe', 'stdin': 'stdin', 'stdin_once': 'stdinOnce', 'termination_message_path': 'terminationMessagePath', 'termination_message_policy': 'terminationMessagePolicy', 'tty': 'tty', 'volume_devices': 'volumeDevices', 'volume_mounts': 'volumeMounts', 'working_dir': 'workingDir'}
command: List[StrictStr] | None
env: List[V1EnvVar] | None
env_from: List[V1EnvFromSource] | None
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1Container from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1Container from a JSON string

image: StrictStr | None
image_pull_policy: StrictStr | None
lifecycle: V1Lifecycle | None
liveness_probe: V1Probe | None
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: StrictStr
openapi_types: ClassVar[Dict[str, str]] = {'args': 'List[str]', 'command': 'List[str]', 'env': 'List[V1EnvVar]', 'env_from': 'List[V1EnvFromSource]', 'image': 'str', 'image_pull_policy': 'str', 'lifecycle': 'V1Lifecycle', 'liveness_probe': 'V1Probe', 'name': 'str', 'ports': 'List[V1ContainerPort]', 'readiness_probe': 'V1Probe', 'resize_policy': 'List[V1ContainerResizePolicy]', 'resources': 'V1ResourceRequirements', 'restart_policy': 'str', 'restart_policy_rules': 'List[V1ContainerRestartRule]', 'security_context': 'V1SecurityContext', 'startup_probe': 'V1Probe', 'stdin': 'bool', 'stdin_once': 'bool', 'termination_message_path': 'str', 'termination_message_policy': 'str', 'tty': 'bool', 'volume_devices': 'List[V1VolumeDevice]', 'volume_mounts': 'List[V1VolumeMount]', 'working_dir': 'str'}
ports: List[V1ContainerPort] | None
readiness_probe: V1Probe | None
resize_policy: List[V1ContainerResizePolicy] | None
resources: V1ResourceRequirements | None
restart_policy: StrictStr | None
restart_policy_rules: List[V1ContainerRestartRule] | None
security_context: V1SecurityContext | None
startup_probe: V1Probe | None
stdin: StrictBool | None
stdin_once: StrictBool | None
termination_message_path: StrictStr | None
termination_message_policy: StrictStr | None
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

tty: StrictBool | None
volume_devices: List[V1VolumeDevice] | None
volume_mounts: List[V1VolumeMount] | None
working_dir: StrictStr | None
class kubernetes.client.models.V1ContainerExtendedResourceRequest(*, container_name: Annotated[str, Strict(strict=True)], request_name: Annotated[str, Strict(strict=True)], resource_name: Annotated[str, Strict(strict=True)])

Bases: BaseModel

ContainerExtendedResourceRequest has the mapping of container name, extended resource name to the device request name.

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.

attribute_map: ClassVar[Dict[str, str]] = {'container_name': 'containerName', 'request_name': 'requestName', 'resource_name': 'resourceName'}
container_name: StrictStr
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1ContainerExtendedResourceRequest from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1ContainerExtendedResourceRequest from a JSON string

model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'container_name': 'str', 'request_name': 'str', 'resource_name': 'str'}
request_name: StrictStr
resource_name: StrictStr
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.V1ContainerImage(*, names: List[Annotated[str, Strict(strict=True)]] | None = None, size_bytes: Annotated[int, Strict(strict=True)] | None = None)

Bases: BaseModel

Describe a container image

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.

attribute_map: ClassVar[Dict[str, str]] = {'names': 'names', 'size_bytes': 'sizeBytes'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1ContainerImage from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1ContainerImage from a JSON string

model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

names: List[StrictStr] | None
openapi_types: ClassVar[Dict[str, str]] = {'names': 'List[str]', 'size_bytes': 'int'}
size_bytes: StrictInt | None
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.V1ContainerPort(*, container_port: Annotated[int, Strict(strict=True)], host_ip: Annotated[str, Strict(strict=True)] | None = None, host_port: Annotated[int, Strict(strict=True)] | None = None, name: Annotated[str, Strict(strict=True)] | None = None, protocol: Annotated[str, Strict(strict=True)] | None = None)

Bases: BaseModel

ContainerPort represents a network port in a single container.

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.

attribute_map: ClassVar[Dict[str, str]] = {'container_port': 'containerPort', 'host_ip': 'hostIP', 'host_port': 'hostPort', 'name': 'name', 'protocol': 'protocol'}
container_port: StrictInt
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1ContainerPort from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1ContainerPort from a JSON string

host_ip: StrictStr | None
host_port: StrictInt | None
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: StrictStr | None
openapi_types: ClassVar[Dict[str, str]] = {'container_port': 'int', 'host_ip': 'str', 'host_port': 'int', 'name': 'str', 'protocol': 'str'}
protocol: StrictStr | None
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.V1ContainerResizePolicy(*, resource_name: Annotated[str, Strict(strict=True)], restart_policy: Annotated[str, Strict(strict=True)])

Bases: BaseModel

ContainerResizePolicy represents resource resize policy for the container.

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.

attribute_map: ClassVar[Dict[str, str]] = {'resource_name': 'resourceName', 'restart_policy': 'restartPolicy'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1ContainerResizePolicy from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1ContainerResizePolicy from a JSON string

model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'resource_name': 'str', 'restart_policy': 'str'}
resource_name: StrictStr
restart_policy: StrictStr
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.V1ContainerRestartRule(*, action: Annotated[str, Strict(strict=True)], exit_codes: V1ContainerRestartRuleOnExitCodes | None = None)

Bases: BaseModel

ContainerRestartRule describes how a container exit is handled.

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.

action: StrictStr
attribute_map: ClassVar[Dict[str, str]] = {'action': 'action', 'exit_codes': 'exitCodes'}
exit_codes: V1ContainerRestartRuleOnExitCodes | None
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1ContainerRestartRule from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1ContainerRestartRule from a JSON string

model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'action': 'str', 'exit_codes': 'V1ContainerRestartRuleOnExitCodes'}
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.V1ContainerRestartRuleOnExitCodes(*, operator: Annotated[str, Strict(strict=True)], values: List[Annotated[int, Strict(strict=True)]] | None = None)

Bases: BaseModel

ContainerRestartRuleOnExitCodes describes the condition for handling an exited container based on its exit codes.

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.

attribute_map: ClassVar[Dict[str, str]] = {'operator': 'operator', 'values': 'values'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1ContainerRestartRuleOnExitCodes from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1ContainerRestartRuleOnExitCodes from a JSON string

model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'operator': 'str', 'values': 'List[int]'}
operator: StrictStr
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

values: List[StrictInt] | None
class kubernetes.client.models.V1ContainerState(*, running: V1ContainerStateRunning | None = None, terminated: V1ContainerStateTerminated | None = None, waiting: V1ContainerStateWaiting | None = None)

Bases: BaseModel

ContainerState holds a possible state of container. Only one of its members may be specified. If none of them is specified, the default one is ContainerStateWaiting.

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.

attribute_map: ClassVar[Dict[str, str]] = {'running': 'running', 'terminated': 'terminated', 'waiting': 'waiting'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1ContainerState from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1ContainerState from a JSON string

model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'running': 'V1ContainerStateRunning', 'terminated': 'V1ContainerStateTerminated', 'waiting': 'V1ContainerStateWaiting'}
running: V1ContainerStateRunning | None
terminated: V1ContainerStateTerminated | None
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

waiting: V1ContainerStateWaiting | None
class kubernetes.client.models.V1ContainerStateRunning(*, started_at: datetime | None = None)

Bases: BaseModel

ContainerStateRunning is a running state of a container.

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.

attribute_map: ClassVar[Dict[str, str]] = {'started_at': 'startedAt'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1ContainerStateRunning from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1ContainerStateRunning from a JSON string

model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'started_at': 'datetime'}
started_at: datetime | None
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.V1ContainerStateTerminated(*, container_id: Annotated[str, Strict(strict=True)] | None = None, exit_code: Annotated[int, Strict(strict=True)], finished_at: datetime | None = None, message: Annotated[str, Strict(strict=True)] | None = None, reason: Annotated[str, Strict(strict=True)] | None = None, signal: Annotated[int, Strict(strict=True)] | None = None, started_at: datetime | None = None)

Bases: BaseModel

ContainerStateTerminated is a terminated state of a container.

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.

attribute_map: ClassVar[Dict[str, str]] = {'container_id': 'containerID', 'exit_code': 'exitCode', 'finished_at': 'finishedAt', 'message': 'message', 'reason': 'reason', 'signal': 'signal', 'started_at': 'startedAt'}
container_id: StrictStr | None
exit_code: StrictInt
finished_at: datetime | None
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1ContainerStateTerminated from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1ContainerStateTerminated from a JSON string

message: StrictStr | None
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'container_id': 'str', 'exit_code': 'int', 'finished_at': 'datetime', 'message': 'str', 'reason': 'str', 'signal': 'int', 'started_at': 'datetime'}
reason: StrictStr | None
signal: StrictInt | None
started_at: datetime | None
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.V1ContainerStateWaiting(*, message: Annotated[str, Strict(strict=True)] | None = None, reason: Annotated[str, Strict(strict=True)] | None = None)

Bases: BaseModel

ContainerStateWaiting is a waiting state of a container.

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.

attribute_map: ClassVar[Dict[str, str]] = {'message': 'message', 'reason': 'reason'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1ContainerStateWaiting from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1ContainerStateWaiting from a JSON string

message: StrictStr | None
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'message': 'str', 'reason': 'str'}
reason: StrictStr | None
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.V1ContainerStatus(*, allocated_resources: Dict[str, Annotated[str, Strict(strict=True)]] | None = None, allocated_resources_status: List[V1ResourceStatus] | None = None, container_id: Annotated[str, Strict(strict=True)] | None = None, image: Annotated[str, Strict(strict=True)], image_id: Annotated[str, Strict(strict=True)], last_state: V1ContainerState | None = None, name: Annotated[str, Strict(strict=True)], ready: Annotated[bool, Strict(strict=True)], resources: V1ResourceRequirements | None = None, restart_count: Annotated[int, Strict(strict=True)], started: Annotated[bool, Strict(strict=True)] | None = None, state: V1ContainerState | None = None, stop_signal: Annotated[str, Strict(strict=True)] | None = None, user: V1ContainerUser | None = None, volume_mounts: List[V1VolumeMountStatus] | None = None)

Bases: BaseModel

ContainerStatus contains details for the current status of this container.

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.

allocated_resources: Dict[str, StrictStr] | None
allocated_resources_status: List[V1ResourceStatus] | None
attribute_map: ClassVar[Dict[str, str]] = {'allocated_resources': 'allocatedResources', 'allocated_resources_status': 'allocatedResourcesStatus', 'container_id': 'containerID', 'image': 'image', 'image_id': 'imageID', 'last_state': 'lastState', 'name': 'name', 'ready': 'ready', 'resources': 'resources', 'restart_count': 'restartCount', 'started': 'started', 'state': 'state', 'stop_signal': 'stopSignal', 'user': 'user', 'volume_mounts': 'volumeMounts'}
container_id: StrictStr | None
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1ContainerStatus from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1ContainerStatus from a JSON string

image: StrictStr
image_id: StrictStr
last_state: V1ContainerState | None
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: StrictStr
openapi_types: ClassVar[Dict[str, str]] = {'allocated_resources': 'Dict[str, str]', 'allocated_resources_status': 'List[V1ResourceStatus]', 'container_id': 'str', 'image': 'str', 'image_id': 'str', 'last_state': 'V1ContainerState', 'name': 'str', 'ready': 'bool', 'resources': 'V1ResourceRequirements', 'restart_count': 'int', 'started': 'bool', 'state': 'V1ContainerState', 'stop_signal': 'str', 'user': 'V1ContainerUser', 'volume_mounts': 'List[V1VolumeMountStatus]'}
ready: StrictBool
resources: V1ResourceRequirements | None
restart_count: StrictInt
started: StrictBool | None
state: V1ContainerState | None
stop_signal: StrictStr | None
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

user: V1ContainerUser | None
volume_mounts: List[V1VolumeMountStatus] | None
class kubernetes.client.models.V1ContainerUser(*, linux: V1LinuxContainerUser | None = None)

Bases: BaseModel

ContainerUser represents user identity information

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.

attribute_map: ClassVar[Dict[str, str]] = {'linux': 'linux'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1ContainerUser from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1ContainerUser from a JSON string

linux: V1LinuxContainerUser | None
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'linux': 'V1LinuxContainerUser'}
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.V1ControllerRevision(*, api_version: Annotated[str, Strict(strict=True)] | None = None, data: Dict[str, Any] | None = None, kind: Annotated[str, Strict(strict=True)] | None = None, metadata: V1ObjectMeta | None = None, revision: Annotated[int, Strict(strict=True)])

Bases: BaseModel

ControllerRevision implements an immutable snapshot of state data. Clients are responsible for serializing and deserializing the objects that contain their internal state. Once a ControllerRevision has been successfully created, it can not be updated. The API Server will fail validation of all requests that attempt to mutate the Data field. ControllerRevisions may, however, be deleted. Note that, due to its use by both the DaemonSet and StatefulSet controllers for update and rollback, this object is beta. However, it may be subject to name and representation changes in future releases, and clients should not depend on its stability. It is primarily for internal use by controllers.

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.

api_version: StrictStr | None
attribute_map: ClassVar[Dict[str, str]] = {'api_version': 'apiVersion', 'data': 'data', 'kind': 'kind', 'metadata': 'metadata', 'revision': 'revision'}
data: Dict[str, Any] | None
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1ControllerRevision from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1ControllerRevision from a JSON string

kind: StrictStr | None
metadata: V1ObjectMeta | None
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'api_version': 'str', 'data': 'object', 'kind': 'str', 'metadata': 'V1ObjectMeta', 'revision': 'int'}
revision: StrictInt
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.V1ControllerRevisionList(*, api_version: Annotated[str, Strict(strict=True)] | None = None, items: List[V1ControllerRevision], kind: Annotated[str, Strict(strict=True)] | None = None, metadata: V1ListMeta | None = None)

Bases: BaseModel

ControllerRevisionList is a resource containing a list of ControllerRevision objects.

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.

api_version: StrictStr | None
attribute_map: ClassVar[Dict[str, str]] = {'api_version': 'apiVersion', 'items': 'items', 'kind': 'kind', 'metadata': 'metadata'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1ControllerRevisionList from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1ControllerRevisionList from a JSON string

items: List[V1ControllerRevision]
kind: StrictStr | None
metadata: V1ListMeta | None
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'api_version': 'str', 'items': 'List[V1ControllerRevision]', 'kind': 'str', 'metadata': 'V1ListMeta'}
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.V1Counter(*, value: Annotated[str, Strict(strict=True)])

Bases: BaseModel

Counter describes a quantity associated with a device.

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.

attribute_map: ClassVar[Dict[str, str]] = {'value': 'value'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1Counter from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1Counter from a JSON string

model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'value': 'str'}
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

value: StrictStr
class kubernetes.client.models.V1CounterSet(*, counters: Dict[str, V1Counter], name: Annotated[str, Strict(strict=True)])

Bases: BaseModel

CounterSet defines a named set of counters that are available to be used by devices defined in the ResourcePool. The counters are not allocatable by themselves, but can be referenced by devices. When a device is allocated, the portion of counters it uses will no longer be available for use by other devices.

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.

attribute_map: ClassVar[Dict[str, str]] = {'counters': 'counters', 'name': 'name'}
counters: Dict[str, V1Counter]
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1CounterSet from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1CounterSet from a JSON string

model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: StrictStr
openapi_types: ClassVar[Dict[str, str]] = {'counters': 'Dict[str, V1Counter]', 'name': 'str'}
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.V1CronJob(*, api_version: Annotated[str, Strict(strict=True)] | None = None, kind: Annotated[str, Strict(strict=True)] | None = None, metadata: V1ObjectMeta | None = None, spec: V1CronJobSpec, status: V1CronJobStatus | None = None)

Bases: BaseModel

CronJob represents the configuration of a single cron job.

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.

api_version: StrictStr | None
attribute_map: ClassVar[Dict[str, str]] = {'api_version': 'apiVersion', 'kind': 'kind', 'metadata': 'metadata', 'spec': 'spec', 'status': 'status'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1CronJob from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1CronJob from a JSON string

kind: StrictStr | None
metadata: V1ObjectMeta | None
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'api_version': 'str', 'kind': 'str', 'metadata': 'V1ObjectMeta', 'spec': 'V1CronJobSpec', 'status': 'V1CronJobStatus'}
spec: V1CronJobSpec
status: V1CronJobStatus | None
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.V1CronJobList(*, api_version: Annotated[str, Strict(strict=True)] | None = None, items: List[V1CronJob], kind: Annotated[str, Strict(strict=True)] | None = None, metadata: V1ListMeta | None = None)

Bases: BaseModel

CronJobList is a collection of cron jobs.

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.

api_version: StrictStr | None
attribute_map: ClassVar[Dict[str, str]] = {'api_version': 'apiVersion', 'items': 'items', 'kind': 'kind', 'metadata': 'metadata'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1CronJobList from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1CronJobList from a JSON string

items: List[V1CronJob]
kind: StrictStr | None
metadata: V1ListMeta | None
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'api_version': 'str', 'items': 'List[V1CronJob]', 'kind': 'str', 'metadata': 'V1ListMeta'}
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.V1CronJobSpec(*, concurrency_policy: Annotated[str, Strict(strict=True)] | None = None, failed_jobs_history_limit: Annotated[int, Strict(strict=True)] | None = None, job_template: V1JobTemplateSpec, schedule: Annotated[str, Strict(strict=True)], starting_deadline_seconds: Annotated[int, Strict(strict=True)] | None = None, successful_jobs_history_limit: Annotated[int, Strict(strict=True)] | None = None, suspend: Annotated[bool, Strict(strict=True)] | None = None, time_zone: Annotated[str, Strict(strict=True)] | None = None)

Bases: BaseModel

CronJobSpec describes how the job execution will look like and when it will actually run.

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.

attribute_map: ClassVar[Dict[str, str]] = {'concurrency_policy': 'concurrencyPolicy', 'failed_jobs_history_limit': 'failedJobsHistoryLimit', 'job_template': 'jobTemplate', 'schedule': 'schedule', 'starting_deadline_seconds': 'startingDeadlineSeconds', 'successful_jobs_history_limit': 'successfulJobsHistoryLimit', 'suspend': 'suspend', 'time_zone': 'timeZone'}
concurrency_policy: StrictStr | None
failed_jobs_history_limit: StrictInt | None
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1CronJobSpec from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1CronJobSpec from a JSON string

job_template: V1JobTemplateSpec
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'concurrency_policy': 'str', 'failed_jobs_history_limit': 'int', 'job_template': 'V1JobTemplateSpec', 'schedule': 'str', 'starting_deadline_seconds': 'int', 'successful_jobs_history_limit': 'int', 'suspend': 'bool', 'time_zone': 'str'}
schedule: StrictStr
starting_deadline_seconds: StrictInt | None
successful_jobs_history_limit: StrictInt | None
suspend: StrictBool | None
time_zone: StrictStr | None
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.V1CronJobStatus(*, active: List[V1ObjectReference] | None = None, last_schedule_time: datetime | None = None, last_successful_time: datetime | None = None)

Bases: BaseModel

CronJobStatus represents the current state of a cron job.

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.

active: List[V1ObjectReference] | None
attribute_map: ClassVar[Dict[str, str]] = {'active': 'active', 'last_schedule_time': 'lastScheduleTime', 'last_successful_time': 'lastSuccessfulTime'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1CronJobStatus from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1CronJobStatus from a JSON string

last_schedule_time: datetime | None
last_successful_time: datetime | None
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'active': 'List[V1ObjectReference]', 'last_schedule_time': 'datetime', 'last_successful_time': 'datetime'}
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.V1CrossVersionObjectReference(*, api_version: Annotated[str, Strict(strict=True)] | None = None, kind: Annotated[str, Strict(strict=True)], name: Annotated[str, Strict(strict=True)])

Bases: BaseModel

CrossVersionObjectReference contains enough information to let you identify the referred resource.

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.

api_version: StrictStr | None
attribute_map: ClassVar[Dict[str, str]] = {'api_version': 'apiVersion', 'kind': 'kind', 'name': 'name'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1CrossVersionObjectReference from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1CrossVersionObjectReference from a JSON string

kind: StrictStr
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: StrictStr
openapi_types: ClassVar[Dict[str, str]] = {'api_version': 'str', 'kind': 'str', 'name': 'str'}
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.V1CustomResourceColumnDefinition(*, description: Annotated[str, Strict(strict=True)] | None = None, format: Annotated[str, Strict(strict=True)] | None = None, json_path: Annotated[str, Strict(strict=True)], name: Annotated[str, Strict(strict=True)], priority: Annotated[int, Strict(strict=True)] | None = None, type: Annotated[str, Strict(strict=True)])

Bases: BaseModel

CustomResourceColumnDefinition specifies a column for server side printing.

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.

attribute_map: ClassVar[Dict[str, str]] = {'description': 'description', 'format': 'format', 'json_path': 'jsonPath', 'name': 'name', 'priority': 'priority', 'type': 'type'}
description: StrictStr | None
format: StrictStr | None
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1CustomResourceColumnDefinition from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1CustomResourceColumnDefinition from a JSON string

json_path: StrictStr
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: StrictStr
openapi_types: ClassVar[Dict[str, str]] = {'description': 'str', 'format': 'str', 'json_path': 'str', 'name': 'str', 'priority': 'int', 'type': 'str'}
priority: StrictInt | None
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

type: StrictStr
class kubernetes.client.models.V1CustomResourceConversion(*, strategy: Annotated[str, Strict(strict=True)], webhook: V1WebhookConversion | None = None)

Bases: BaseModel

CustomResourceConversion describes how to convert different versions of a CR.

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.

attribute_map: ClassVar[Dict[str, str]] = {'strategy': 'strategy', 'webhook': 'webhook'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1CustomResourceConversion from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1CustomResourceConversion from a JSON string

model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'strategy': 'str', 'webhook': 'V1WebhookConversion'}
strategy: StrictStr
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

webhook: V1WebhookConversion | None
class kubernetes.client.models.V1CustomResourceDefinition(*, api_version: Annotated[str, Strict(strict=True)] | None = None, kind: Annotated[str, Strict(strict=True)] | None = None, metadata: V1ObjectMeta | None = None, spec: V1CustomResourceDefinitionSpec, status: V1CustomResourceDefinitionStatus | None = None)

Bases: BaseModel

CustomResourceDefinition represents a resource that should be exposed on the API server. Its name MUST be in the format <.spec.name>.<.spec.group>.

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.

api_version: StrictStr | None
attribute_map: ClassVar[Dict[str, str]] = {'api_version': 'apiVersion', 'kind': 'kind', 'metadata': 'metadata', 'spec': 'spec', 'status': 'status'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1CustomResourceDefinition from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1CustomResourceDefinition from a JSON string

kind: StrictStr | None
metadata: V1ObjectMeta | None
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'api_version': 'str', 'kind': 'str', 'metadata': 'V1ObjectMeta', 'spec': 'V1CustomResourceDefinitionSpec', 'status': 'V1CustomResourceDefinitionStatus'}
spec: V1CustomResourceDefinitionSpec
status: V1CustomResourceDefinitionStatus | None
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.V1CustomResourceDefinitionCondition(*, last_transition_time: datetime | None = None, message: Annotated[str, Strict(strict=True)] | None = None, observed_generation: Annotated[int, Strict(strict=True)] | None = None, reason: Annotated[str, Strict(strict=True)] | None = None, status: Annotated[str, Strict(strict=True)], type: Annotated[str, Strict(strict=True)])

Bases: BaseModel

CustomResourceDefinitionCondition contains details for the current condition of this pod.

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.

attribute_map: ClassVar[Dict[str, str]] = {'last_transition_time': 'lastTransitionTime', 'message': 'message', 'observed_generation': 'observedGeneration', 'reason': 'reason', 'status': 'status', 'type': 'type'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1CustomResourceDefinitionCondition from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1CustomResourceDefinitionCondition from a JSON string

last_transition_time: datetime | None
message: StrictStr | None
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

observed_generation: StrictInt | None
openapi_types: ClassVar[Dict[str, str]] = {'last_transition_time': 'datetime', 'message': 'str', 'observed_generation': 'int', 'reason': 'str', 'status': 'str', 'type': 'str'}
reason: StrictStr | None
status: StrictStr
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

type: StrictStr
class kubernetes.client.models.V1CustomResourceDefinitionList(*, api_version: Annotated[str, Strict(strict=True)] | None = None, items: List[V1CustomResourceDefinition], kind: Annotated[str, Strict(strict=True)] | None = None, metadata: V1ListMeta | None = None)

Bases: BaseModel

CustomResourceDefinitionList is a list of CustomResourceDefinition objects.

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.

api_version: StrictStr | None
attribute_map: ClassVar[Dict[str, str]] = {'api_version': 'apiVersion', 'items': 'items', 'kind': 'kind', 'metadata': 'metadata'}
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1CustomResourceDefinitionList from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1CustomResourceDefinitionList from a JSON string

items: List[V1CustomResourceDefinition]
kind: StrictStr | None
metadata: V1ListMeta | None
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'api_version': 'str', 'items': 'List[V1CustomResourceDefinition]', 'kind': 'str', 'metadata': 'V1ListMeta'}
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.V1CustomResourceDefinitionNames(*, categories: List[Annotated[str, Strict(strict=True)]] | None = None, kind: Annotated[str, Strict(strict=True)], list_kind: Annotated[str, Strict(strict=True)] | None = None, plural: Annotated[str, Strict(strict=True)], short_names: List[Annotated[str, Strict(strict=True)]] | None = None, singular: Annotated[str, Strict(strict=True)] | None = None)

Bases: BaseModel

CustomResourceDefinitionNames indicates the names to serve this CustomResourceDefinition

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.

attribute_map: ClassVar[Dict[str, str]] = {'categories': 'categories', 'kind': 'kind', 'list_kind': 'listKind', 'plural': 'plural', 'short_names': 'shortNames', 'singular': 'singular'}
categories: List[StrictStr] | None
classmethod from_dict(obj: Dict[str, Any] | None) → Self | None

Create an instance of V1CustomResourceDefinitionNames from a dict

classmethod from_json(json_str: str) → Self | None

Create an instance of V1CustomResourceDefinitionNames from a JSON string

kind: StrictStr
list_kind: StrictStr | None
model_config = {'extra': 'forbid', 'protected_namespaces': (), 'validate_assignment': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

openapi_types: ClassVar[Dict[str, str]] = {'categories': 'List[str]', 'kind': 'str', 'list_kind': 'str', 'plural': 'str', 'short_names': 'List[str]', 'singular': 'str'}
plural: StrictStr
short_names: List[StrictStr] | None
singular: StrictStr | None
to_dict(serialize: bool = False) → Dict[str, Any]

Return all declared model fields using public or wire names.

to_json() → str

Returns the JSON representation of the model using alias

to_str() → str

Returns the string representation of the model

class kubernetes.client.models.V1CustomResourceDefinitionSpec(*, conversion: V1CustomResourceConversion | None = None, group: Annotated[str, Strict(strict=True)], names: V1CustomResourceDefinitionNames, preserve_unknown_fields: Annotated[bool, Strict</