python/services/container/cluster.py

# Copyright 2021 Google LLC. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from connector import channel from google3.cloud.graphite.mmv2.services.google.container import cluster_pb2 from google3.cloud.graphite.mmv2.services.google.container import cluster_pb2_grpc from typing import List class Cluster(object): def __init__( self, name: str = None, description: str = None, initial_node_count: int = None, master_auth: dict = None, logging_service: str = None, monitoring_service: str = None, network: str = None, cluster_ipv4_cidr: str = None, addons_config: dict = None, subnetwork: str = None, node_pools: list = None, locations: list = None, enable_kubernetes_alpha: bool = None, resource_labels: dict = None, label_fingerprint: str = None, legacy_abac: dict = None, network_policy: dict = None, ip_allocation_policy: dict = None, master_authorized_networks_config: dict = None, binary_authorization: dict = None, autoscaling: dict = None, network_config: dict = None, maintenance_policy: dict = None, default_max_pods_constraint: dict = None, resource_usage_export_config: dict = None, authenticator_groups_config: dict = None, private_cluster_config: dict = None, database_encryption: dict = None, vertical_pod_autoscaling: dict = None, shielded_nodes: dict = None, endpoint: str = None, master_version: str = None, create_time: str = None, status: str = None, status_message: str = None, node_ipv4_cidr_size: int = None, services_ipv4_cidr: str = None, expire_time: str = None, location: str = None, enable_tpu: bool = None, tpu_ipv4_cidr_block: str = None, conditions: list = None, autopilot: dict = None, project: str = None, node_config: dict = None, release_channel: dict = None, workload_identity_config: dict = None, notification_config: dict = None, confidential_nodes: dict = None, self_link: str = None, zone: str = None, initial_cluster_version: str = None, current_master_version: str = None, current_node_version: str = None, instance_group_urls: list = None, current_node_count: int = None, id: str = None, service_account_file: str = "", ): channel.initialize() self.name = name self.description = description self.initial_node_count = initial_node_count self.master_auth = master_auth self.logging_service = logging_service self.monitoring_service = monitoring_service self.network = network self.cluster_ipv4_cidr = cluster_ipv4_cidr self.addons_config = addons_config self.subnetwork = subnetwork self.node_pools = node_pools self.locations = locations self.enable_kubernetes_alpha = enable_kubernetes_alpha self.resource_labels = resource_labels self.label_fingerprint = label_fingerprint self.legacy_abac = legacy_abac self.network_policy = network_policy self.ip_allocation_policy = ip_allocation_policy self.master_authorized_networks_config = master_authorized_networks_config self.binary_authorization = binary_authorization self.autoscaling = autoscaling self.network_config = network_config self.maintenance_policy = maintenance_policy self.default_max_pods_constraint = default_max_pods_constraint self.resource_usage_export_config = resource_usage_export_config self.authenticator_groups_config = authenticator_groups_config self.private_cluster_config = private_cluster_config self.database_encryption = database_encryption self.vertical_pod_autoscaling = vertical_pod_autoscaling self.shielded_nodes = shielded_nodes self.master_version = master_version self.location = location self.enable_tpu = enable_tpu self.conditions = conditions self.autopilot = autopilot self.project = project self.node_config = node_config self.release_channel = release_channel self.workload_identity_config = workload_identity_config self.notification_config = notification_config self.confidential_nodes = confidential_nodes self.initial_cluster_version = initial_cluster_version self.instance_group_urls = instance_group_urls self.service_account_file = service_account_file def apply(self): stub = cluster_pb2_grpc.ContainerClusterServiceStub(channel.Channel()) request = cluster_pb2.ApplyContainerClusterRequest() if Primitive.to_proto(self.name): request.resource.name = Primitive.to_proto(self.name) if Primitive.to_proto(self.description): request.resource.description = Primitive.to_proto(self.description) if Primitive.to_proto(self.initial_node_count): request.resource.initial_node_count = Primitive.to_proto( self.initial_node_count ) if ClusterMasterAuth.to_proto(self.master_auth): request.resource.master_auth.CopyFrom( ClusterMasterAuth.to_proto(self.master_auth) ) else: request.resource.ClearField("master_auth") if Primitive.to_proto(self.logging_service): request.resource.logging_service = Primitive.to_proto(self.logging_service) if Primitive.to_proto(self.monitoring_service): request.resource.monitoring_service = Primitive.to_proto( self.monitoring_service ) if Primitive.to_proto(self.network): request.resource.network = Primitive.to_proto(self.network) if Primitive.to_proto(self.cluster_ipv4_cidr): request.resource.cluster_ipv4_cidr = Primitive.to_proto( self.cluster_ipv4_cidr ) if ClusterAddonsConfig.to_proto(self.addons_config): request.resource.addons_config.CopyFrom( ClusterAddonsConfig.to_proto(self.addons_config) ) else: request.resource.ClearField("addons_config") if Primitive.to_proto(self.subnetwork): request.resource.subnetwork = Primitive.to_proto(self.subnetwork) if ClusterNodePoolsArray.to_proto(self.node_pools): request.resource.node_pools.extend( ClusterNodePoolsArray.to_proto(self.node_pools) ) if Primitive.to_proto(self.locations): request.resource.locations.extend(Primitive.to_proto(self.locations)) if Primitive.to_proto(self.enable_kubernetes_alpha): request.resource.enable_kubernetes_alpha = Primitive.to_proto( self.enable_kubernetes_alpha ) if Primitive.to_proto(self.resource_labels): request.resource.resource_labels = Primitive.to_proto(self.resource_labels) if Primitive.to_proto(self.label_fingerprint): request.resource.label_fingerprint = Primitive.to_proto( self.label_fingerprint ) if ClusterLegacyAbac.to_proto(self.legacy_abac): request.resource.legacy_abac.CopyFrom( ClusterLegacyAbac.to_proto(self.legacy_abac) ) else: request.resource.ClearField("legacy_abac") if ClusterNetworkPolicy.to_proto(self.network_policy): request.resource.network_policy.CopyFrom( ClusterNetworkPolicy.to_proto(self.network_policy) ) else: request.resource.ClearField("network_policy") if ClusterIPAllocationPolicy.to_proto(self.ip_allocation_policy): request.resource.ip_allocation_policy.CopyFrom( ClusterIPAllocationPolicy.to_proto(self.ip_allocation_policy) ) else: request.resource.ClearField("ip_allocation_policy") if ClusterMasterAuthorizedNetworksConfig.to_proto( self.master_authorized_networks_config ): request.resource.master_authorized_networks_config.CopyFrom( ClusterMasterAuthorizedNetworksConfig.to_proto( self.master_authorized_networks_config ) ) else: request.resource.ClearField("master_authorized_networks_config") if ClusterBinaryAuthorization.to_proto(self.binary_authorization): request.resource.binary_authorization.CopyFrom( ClusterBinaryAuthorization.to_proto(self.binary_authorization) ) else: request.resource.ClearField("binary_authorization") if ClusterAutoscaling.to_proto(self.autoscaling): request.resource.autoscaling.CopyFrom( ClusterAutoscaling.to_proto(self.autoscaling) ) else: request.resource.ClearField("autoscaling") if ClusterNetworkConfig.to_proto(self.network_config): request.resource.network_config.CopyFrom( ClusterNetworkConfig.to_proto(self.network_config) ) else: request.resource.ClearField("network_config") if ClusterMaintenancePolicy.to_proto(self.maintenance_policy): request.resource.maintenance_policy.CopyFrom( ClusterMaintenancePolicy.to_proto(self.maintenance_policy) ) else: request.resource.ClearField("maintenance_policy") if ClusterDefaultMaxPodsConstraint.to_proto(self.default_max_pods_constraint): request.resource.default_max_pods_constraint.CopyFrom( ClusterDefaultMaxPodsConstraint.to_proto( self.default_max_pods_constraint ) ) else: request.resource.ClearField("default_max_pods_constraint") if ClusterResourceUsageExportConfig.to_proto(self.resource_usage_export_config): request.resource.resource_usage_export_config.CopyFrom( ClusterResourceUsageExportConfig.to_proto( self.resource_usage_export_config ) ) else: request.resource.ClearField("resource_usage_export_config") if ClusterAuthenticatorGroupsConfig.to_proto(self.authenticator_groups_config): request.resource.authenticator_groups_config.CopyFrom( ClusterAuthenticatorGroupsConfig.to_proto( self.authenticator_groups_config ) ) else: request.resource.ClearField("authenticator_groups_config") if ClusterPrivateClusterConfig.to_proto(self.private_cluster_config): request.resource.private_cluster_config.CopyFrom( ClusterPrivateClusterConfig.to_proto(self.private_cluster_config) ) else: request.resource.ClearField("private_cluster_config") if ClusterDatabaseEncryption.to_proto(self.database_encryption): request.resource.database_encryption.CopyFrom( ClusterDatabaseEncryption.to_proto(self.database_encryption) ) else: request.resource.ClearField("database_encryption") if ClusterVerticalPodAutoscaling.to_proto(self.vertical_pod_autoscaling): request.resource.vertical_pod_autoscaling.CopyFrom( ClusterVerticalPodAutoscaling.to_proto(self.vertical_pod_autoscaling) ) else: request.resource.ClearField("vertical_pod_autoscaling") if ClusterShieldedNodes.to_proto(self.shielded_nodes): request.resource.shielded_nodes.CopyFrom( ClusterShieldedNodes.to_proto(self.shielded_nodes) ) else: request.resource.ClearField("shielded_nodes") if Primitive.to_proto(self.master_version): request.resource.master_version = Primitive.to_proto(self.master_version) if Primitive.to_proto(self.location): request.resource.location = Primitive.to_proto(self.location) if Primitive.to_proto(self.enable_tpu): request.resource.enable_tpu = Primitive.to_proto(self.enable_tpu) if ClusterConditionsArray.to_proto(self.conditions): request.resource.conditions.extend( ClusterConditionsArray.to_proto(self.conditions) ) if ClusterAutopilot.to_proto(self.autopilot): request.resource.autopilot.CopyFrom( ClusterAutopilot.to_proto(self.autopilot) ) else: request.resource.ClearField("autopilot") if Primitive.to_proto(self.project): request.resource.project = Primitive.to_proto(self.project) if ClusterNodeConfig.to_proto(self.node_config): request.resource.node_config.CopyFrom( ClusterNodeConfig.to_proto(self.node_config) ) else: request.resource.ClearField("node_config") if ClusterReleaseChannel.to_proto(self.release_channel): request.resource.release_channel.CopyFrom( ClusterReleaseChannel.to_proto(self.release_channel) ) else: request.resource.ClearField("release_channel") if ClusterWorkloadIdentityConfig.to_proto(self.workload_identity_config): request.resource.workload_identity_config.CopyFrom( ClusterWorkloadIdentityConfig.to_proto(self.workload_identity_config) ) else: request.resource.ClearField("workload_identity_config") if ClusterNotificationConfig.to_proto(self.notification_config): request.resource.notification_config.CopyFrom( ClusterNotificationConfig.to_proto(self.notification_config) ) else: request.resource.ClearField("notification_config") if ClusterConfidentialNodes.to_proto(self.confidential_nodes): request.resource.confidential_nodes.CopyFrom( ClusterConfidentialNodes.to_proto(self.confidential_nodes) ) else: request.resource.ClearField("confidential_nodes") if Primitive.to_proto(self.initial_cluster_version): request.resource.initial_cluster_version = Primitive.to_proto( self.initial_cluster_version ) if Primitive.to_proto(self.instance_group_urls): request.resource.instance_group_urls.extend( Primitive.to_proto(self.instance_group_urls) ) request.service_account_file = self.service_account_file response = stub.ApplyContainerCluster(request) self.name = Primitive.from_proto(response.name) self.description = Primitive.from_proto(response.description) self.initial_node_count = Primitive.from_proto(response.initial_node_count) self.master_auth = ClusterMasterAuth.from_proto(response.master_auth) self.logging_service = Primitive.from_proto(response.logging_service) self.monitoring_service = Primitive.from_proto(response.monitoring_service) self.network = Primitive.from_proto(response.network) self.cluster_ipv4_cidr = Primitive.from_proto(response.cluster_ipv4_cidr) self.addons_config = ClusterAddonsConfig.from_proto(response.addons_config) self.subnetwork = Primitive.from_proto(response.subnetwork) self.node_pools = ClusterNodePoolsArray.from_proto(response.node_pools) self.locations = Primitive.from_proto(response.locations) self.enable_kubernetes_alpha = Primitive.from_proto( response.enable_kubernetes_alpha ) self.resource_labels = Primitive.from_proto(response.resource_labels) self.label_fingerprint = Primitive.from_proto(response.label_fingerprint) self.legacy_abac = ClusterLegacyAbac.from_proto(response.legacy_abac) self.network_policy = ClusterNetworkPolicy.from_proto(response.network_policy) self.ip_allocation_policy = ClusterIPAllocationPolicy.from_proto( response.ip_allocation_policy ) self.master_authorized_networks_config = ClusterMasterAuthorizedNetworksConfig.from_proto( response.master_authorized_networks_config ) self.binary_authorization = ClusterBinaryAuthorization.from_proto( response.binary_authorization ) self.autoscaling = ClusterAutoscaling.from_proto(response.autoscaling) self.network_config = ClusterNetworkConfig.from_proto(response.network_config) self.maintenance_policy = ClusterMaintenancePolicy.from_proto( response.maintenance_policy ) self.default_max_pods_constraint = ClusterDefaultMaxPodsConstraint.from_proto( response.default_max_pods_constraint ) self.resource_usage_export_config = ClusterResourceUsageExportConfig.from_proto( response.resource_usage_export_config ) self.authenticator_groups_config = ClusterAuthenticatorGroupsConfig.from_proto( response.authenticator_groups_config ) self.private_cluster_config = ClusterPrivateClusterConfig.from_proto( response.private_cluster_config ) self.database_encryption = ClusterDatabaseEncryption.from_proto( response.database_encryption ) self.vertical_pod_autoscaling = ClusterVerticalPodAutoscaling.from_proto( response.vertical_pod_autoscaling ) self.shielded_nodes = ClusterShieldedNodes.from_proto(response.shielded_nodes) self.endpoint = Primitive.from_proto(response.endpoint) self.master_version = Primitive.from_proto(response.master_version) self.create_time = Primitive.from_proto(response.create_time) self.status = Primitive.from_proto(response.status) self.status_message = Primitive.from_proto(response.status_message) self.node_ipv4_cidr_size = Primitive.from_proto(response.node_ipv4_cidr_size) self.services_ipv4_cidr = Primitive.from_proto(response.services_ipv4_cidr) self.expire_time = Primitive.from_proto(response.expire_time) self.location = Primitive.from_proto(response.location) self.enable_tpu = Primitive.from_proto(response.enable_tpu) self.tpu_ipv4_cidr_block = Primitive.from_proto(response.tpu_ipv4_cidr_block) self.conditions = ClusterConditionsArray.from_proto(response.conditions) self.autopilot = ClusterAutopilot.from_proto(response.autopilot) self.project = Primitive.from_proto(response.project) self.node_config = ClusterNodeConfig.from_proto(response.node_config) self.release_channel = ClusterReleaseChannel.from_proto( response.release_channel ) self.workload_identity_config = ClusterWorkloadIdentityConfig.from_proto( response.workload_identity_config ) self.notification_config = ClusterNotificationConfig.from_proto( response.notification_config ) self.confidential_nodes = ClusterConfidentialNodes.from_proto( response.confidential_nodes ) self.self_link = Primitive.from_proto(response.self_link) self.zone = Primitive.from_proto(response.zone) self.initial_cluster_version = Primitive.from_proto( response.initial_cluster_version ) self.current_master_version = Primitive.from_proto( response.current_master_version ) self.current_node_version = Primitive.from_proto(response.current_node_version) self.instance_group_urls = Primitive.from_proto(response.instance_group_urls) self.current_node_count = Primitive.from_proto(response.current_node_count) self.id = Primitive.from_proto(response.id) def delete(self): stub = cluster_pb2_grpc.ContainerClusterServiceStub(channel.Channel()) request = cluster_pb2.DeleteContainerClusterRequest() request.service_account_file = self.service_account_file if Primitive.to_proto(self.name): request.resource.name = Primitive.to_proto(self.name) if Primitive.to_proto(self.description): request.resource.description = Primitive.to_proto(self.description) if Primitive.to_proto(self.initial_node_count): request.resource.initial_node_count = Primitive.to_proto( self.initial_node_count ) if ClusterMasterAuth.to_proto(self.master_auth): request.resource.master_auth.CopyFrom( ClusterMasterAuth.to_proto(self.master_auth) ) else: request.resource.ClearField("master_auth") if Primitive.to_proto(self.logging_service): request.resource.logging_service = Primitive.to_proto(self.logging_service) if Primitive.to_proto(self.monitoring_service): request.resource.monitoring_service = Primitive.to_proto( self.monitoring_service ) if Primitive.to_proto(self.network): request.resource.network = Primitive.to_proto(self.network) if Primitive.to_proto(self.cluster_ipv4_cidr): request.resource.cluster_ipv4_cidr = Primitive.to_proto( self.cluster_ipv4_cidr ) if ClusterAddonsConfig.to_proto(self.addons_config): request.resource.addons_config.CopyFrom( ClusterAddonsConfig.to_proto(self.addons_config) ) else: request.resource.ClearField("addons_config") if Primitive.to_proto(self.subnetwork): request.resource.subnetwork = Primitive.to_proto(self.subnetwork) if ClusterNodePoolsArray.to_proto(self.node_pools): request.resource.node_pools.extend( ClusterNodePoolsArray.to_proto(self.node_pools) ) if Primitive.to_proto(self.locations): request.resource.locations.extend(Primitive.to_proto(self.locations)) if Primitive.to_proto(self.enable_kubernetes_alpha): request.resource.enable_kubernetes_alpha = Primitive.to_proto( self.enable_kubernetes_alpha ) if Primitive.to_proto(self.resource_labels): request.resource.resource_labels = Primitive.to_proto(self.resource_labels) if Primitive.to_proto(self.label_fingerprint): request.resource.label_fingerprint = Primitive.to_proto( self.label_fingerprint ) if ClusterLegacyAbac.to_proto(self.legacy_abac): request.resource.legacy_abac.CopyFrom( ClusterLegacyAbac.to_proto(self.legacy_abac) ) else: request.resource.ClearField("legacy_abac") if ClusterNetworkPolicy.to_proto(self.network_policy): request.resource.network_policy.CopyFrom( ClusterNetworkPolicy.to_proto(self.network_policy) ) else: request.resource.ClearField("network_policy") if ClusterIPAllocationPolicy.to_proto(self.ip_allocation_policy): request.resource.ip_allocation_policy.CopyFrom( ClusterIPAllocationPolicy.to_proto(self.ip_allocation_policy) ) else: request.resource.ClearField("ip_allocation_policy") if ClusterMasterAuthorizedNetworksConfig.to_proto( self.master_authorized_networks_config ): request.resource.master_authorized_networks_config.CopyFrom( ClusterMasterAuthorizedNetworksConfig.to_proto( self.master_authorized_networks_config ) ) else: request.resource.ClearField("master_authorized_networks_config") if ClusterBinaryAuthorization.to_proto(self.binary_authorization): request.resource.binary_authorization.CopyFrom( ClusterBinaryAuthorization.to_proto(self.binary_authorization) ) else: request.resource.ClearField("binary_authorization") if ClusterAutoscaling.to_proto(self.autoscaling): request.resource.autoscaling.CopyFrom( ClusterAutoscaling.to_proto(self.autoscaling) ) else: request.resource.ClearField("autoscaling") if ClusterNetworkConfig.to_proto(self.network_config): request.resource.network_config.CopyFrom( ClusterNetworkConfig.to_proto(self.network_config) ) else: request.resource.ClearField("network_config") if ClusterMaintenancePolicy.to_proto(self.maintenance_policy): request.resource.maintenance_policy.CopyFrom( ClusterMaintenancePolicy.to_proto(self.maintenance_policy) ) else: request.resource.ClearField("maintenance_policy") if ClusterDefaultMaxPodsConstraint.to_proto(self.default_max_pods_constraint): request.resource.default_max_pods_constraint.CopyFrom( ClusterDefaultMaxPodsConstraint.to_proto( self.default_max_pods_constraint ) ) else: request.resource.ClearField("default_max_pods_constraint") if ClusterResourceUsageExportConfig.to_proto(self.resource_usage_export_config): request.resource.resource_usage_export_config.CopyFrom( ClusterResourceUsageExportConfig.to_proto( self.resource_usage_export_config ) ) else: request.resource.ClearField("resource_usage_export_config") if ClusterAuthenticatorGroupsConfig.to_proto(self.authenticator_groups_config): request.resource.authenticator_groups_config.CopyFrom( ClusterAuthenticatorGroupsConfig.to_proto( self.authenticator_groups_config ) ) else: request.resource.ClearField("authenticator_groups_config") if ClusterPrivateClusterConfig.to_proto(self.private_cluster_config): request.resource.private_cluster_config.CopyFrom( ClusterPrivateClusterConfig.to_proto(self.private_cluster_config) ) else: request.resource.ClearField("private_cluster_config") if ClusterDatabaseEncryption.to_proto(self.database_encryption): request.resource.database_encryption.CopyFrom( ClusterDatabaseEncryption.to_proto(self.database_encryption) ) else: request.resource.ClearField("database_encryption") if ClusterVerticalPodAutoscaling.to_proto(self.vertical_pod_autoscaling): request.resource.vertical_pod_autoscaling.CopyFrom( ClusterVerticalPodAutoscaling.to_proto(self.vertical_pod_autoscaling) ) else: request.resource.ClearField("vertical_pod_autoscaling") if ClusterShieldedNodes.to_proto(self.shielded_nodes): request.resource.shielded_nodes.CopyFrom( ClusterShieldedNodes.to_proto(self.shielded_nodes) ) else: request.resource.ClearField("shielded_nodes") if Primitive.to_proto(self.master_version): request.resource.master_version = Primitive.to_proto(self.master_version) if Primitive.to_proto(self.location): request.resource.location = Primitive.to_proto(self.location) if Primitive.to_proto(self.enable_tpu): request.resource.enable_tpu = Primitive.to_proto(self.enable_tpu) if ClusterConditionsArray.to_proto(self.conditions): request.resource.conditions.extend( ClusterConditionsArray.to_proto(self.conditions) ) if ClusterAutopilot.to_proto(self.autopilot): request.resource.autopilot.CopyFrom( ClusterAutopilot.to_proto(self.autopilot) ) else: request.resource.ClearField("autopilot") if Primitive.to_proto(self.project): request.resource.project = Primitive.to_proto(self.project) if ClusterNodeConfig.to_proto(self.node_config): request.resource.node_config.CopyFrom( ClusterNodeConfig.to_proto(self.node_config) ) else: request.resource.ClearField("node_config") if ClusterReleaseChannel.to_proto(self.release_channel): request.resource.release_channel.CopyFrom( ClusterReleaseChannel.to_proto(self.release_channel) ) else: request.resource.ClearField("release_channel") if ClusterWorkloadIdentityConfig.to_proto(self.workload_identity_config): request.resource.workload_identity_config.CopyFrom( ClusterWorkloadIdentityConfig.to_proto(self.workload_identity_config) ) else: request.resource.ClearField("workload_identity_config") if ClusterNotificationConfig.to_proto(self.notification_config): request.resource.notification_config.CopyFrom( ClusterNotificationConfig.to_proto(self.notification_config) ) else: request.resource.ClearField("notification_config") if ClusterConfidentialNodes.to_proto(self.confidential_nodes): request.resource.confidential_nodes.CopyFrom( ClusterConfidentialNodes.to_proto(self.confidential_nodes) ) else: request.resource.ClearField("confidential_nodes") if Primitive.to_proto(self.initial_cluster_version): request.resource.initial_cluster_version = Primitive.to_proto( self.initial_cluster_version ) if Primitive.to_proto(self.instance_group_urls): request.resource.instance_group_urls.extend( Primitive.to_proto(self.instance_group_urls) ) response = stub.DeleteContainerCluster(request) @classmethod def list(self, project, location, service_account_file=""): stub = cluster_pb2_grpc.ContainerClusterServiceStub(channel.Channel()) request = cluster_pb2.ListContainerClusterRequest() request.service_account_file = service_account_file request.Project = project request.Location = location return stub.ListContainerCluster(request).items def to_proto(self): resource = cluster_pb2.ContainerCluster() if Primitive.to_proto(self.name): resource.name = Primitive.to_proto(self.name) if Primitive.to_proto(self.description): resource.description = Primitive.to_proto(self.description) if Primitive.to_proto(self.initial_node_count): resource.initial_node_count = Primitive.to_proto(self.initial_node_count) if ClusterMasterAuth.to_proto(self.master_auth): resource.master_auth.CopyFrom(ClusterMasterAuth.to_proto(self.master_auth)) else: resource.ClearField("master_auth") if Primitive.to_proto(self.logging_service): resource.logging_service = Primitive.to_proto(self.logging_service) if Primitive.to_proto(self.monitoring_service): resource.monitoring_service = Primitive.to_proto(self.monitoring_service) if Primitive.to_proto(self.network): resource.network = Primitive.to_proto(self.network) if Primitive.to_proto(self.cluster_ipv4_cidr): resource.cluster_ipv4_cidr = Primitive.to_proto(self.cluster_ipv4_cidr) if ClusterAddonsConfig.to_proto(self.addons_config): resource.addons_config.CopyFrom( ClusterAddonsConfig.to_proto(self.addons_config) ) else: resource.ClearField("addons_config") if Primitive.to_proto(self.subnetwork): resource.subnetwork = Primitive.to_proto(self.subnetwork) if ClusterNodePoolsArray.to_proto(self.node_pools): resource.node_pools.extend(ClusterNodePoolsArray.to_proto(self.node_pools)) if Primitive.to_proto(self.locations): resource.locations.extend(Primitive.to_proto(self.locations)) if Primitive.to_proto(self.enable_kubernetes_alpha): resource.enable_kubernetes_alpha = Primitive.to_proto( self.enable_kubernetes_alpha ) if Primitive.to_proto(self.resource_labels): resource.resource_labels = Primitive.to_proto(self.resource_labels) if Primitive.to_proto(self.label_fingerprint): resource.label_fingerprint = Primitive.to_proto(self.label_fingerprint) if ClusterLegacyAbac.to_proto(self.legacy_abac): resource.legacy_abac.CopyFrom(ClusterLegacyAbac.to_proto(self.legacy_abac)) else: resource.ClearField("legacy_abac") if ClusterNetworkPolicy.to_proto(self.network_policy): resource.network_policy.CopyFrom( ClusterNetworkPolicy.to_proto(self.network_policy) ) else: resource.ClearField("network_policy") if ClusterIPAllocationPolicy.to_proto(self.ip_allocation_policy): resource.ip_allocation_policy.CopyFrom( ClusterIPAllocationPolicy.to_proto(self.ip_allocation_policy) ) else: resource.ClearField("ip_allocation_policy") if ClusterMasterAuthorizedNetworksConfig.to_proto( self.master_authorized_networks_config ): resource.master_authorized_networks_config.CopyFrom( ClusterMasterAuthorizedNetworksConfig.to_proto( self.master_authorized_networks_config ) ) else: resource.ClearField("master_authorized_networks_config") if ClusterBinaryAuthorization.to_proto(self.binary_authorization): resource.binary_authorization.CopyFrom( ClusterBinaryAuthorization.to_proto(self.binary_authorization) ) else: resource.ClearField("binary_authorization") if ClusterAutoscaling.to_proto(self.autoscaling): resource.autoscaling.CopyFrom(ClusterAutoscaling.to_proto(self.autoscaling)) else: resource.ClearField("autoscaling") if ClusterNetworkConfig.to_proto(self.network_config): resource.network_config.CopyFrom( ClusterNetworkConfig.to_proto(self.network_config) ) else: resource.ClearField("network_config") if ClusterMaintenancePolicy.to_proto(self.maintenance_policy): resource.maintenance_policy.CopyFrom( ClusterMaintenancePolicy.to_proto(self.maintenance_policy) ) else: resource.ClearField("maintenance_policy") if ClusterDefaultMaxPodsConstraint.to_proto(self.default_max_pods_constraint): resource.default_max_pods_constraint.CopyFrom( ClusterDefaultMaxPodsConstraint.to_proto( self.default_max_pods_constraint ) ) else: resource.ClearField("default_max_pods_constraint") if ClusterResourceUsageExportConfig.to_proto(self.resource_usage_export_config): resource.resource_usage_export_config.CopyFrom( ClusterResourceUsageExportConfig.to_proto( self.resource_usage_export_config ) ) else: resource.ClearField("resource_usage_export_config") if ClusterAuthenticatorGroupsConfig.to_proto(self.authenticator_groups_config): resource.authenticator_groups_config.CopyFrom( ClusterAuthenticatorGroupsConfig.to_proto( self.authenticator_groups_config ) ) else: resource.ClearField("authenticator_groups_config") if ClusterPrivateClusterConfig.to_proto(self.private_cluster_config): resource.private_cluster_config.CopyFrom( ClusterPrivateClusterConfig.to_proto(self.private_cluster_config) ) else: resource.ClearField("private_cluster_config") if ClusterDatabaseEncryption.to_proto(self.database_encryption): resource.database_encryption.CopyFrom( ClusterDatabaseEncryption.to_proto(self.database_encryption) ) else: resource.ClearField("database_encryption") if ClusterVerticalPodAutoscaling.to_proto(self.vertical_pod_autoscaling): resource.vertical_pod_autoscaling.CopyFrom( ClusterVerticalPodAutoscaling.to_proto(self.vertical_pod_autoscaling) ) else: resource.ClearField("vertical_pod_autoscaling") if ClusterShieldedNodes.to_proto(self.shielded_nodes): resource.shielded_nodes.CopyFrom( ClusterShieldedNodes.to_proto(self.shielded_nodes) ) else: resource.ClearField("shielded_nodes") if Primitive.to_proto(self.master_version): resource.master_version = Primitive.to_proto(self.master_version) if Primitive.to_proto(self.location): resource.location = Primitive.to_proto(self.location) if Primitive.to_proto(self.enable_tpu): resource.enable_tpu = Primitive.to_proto(self.enable_tpu) if ClusterConditionsArray.to_proto(self.conditions): resource.conditions.extend(ClusterConditionsArray.to_proto(self.conditions)) if ClusterAutopilot.to_proto(self.autopilot): resource.autopilot.CopyFrom(ClusterAutopilot.to_proto(self.autopilot)) else: resource.ClearField("autopilot") if Primitive.to_proto(self.project): resource.project = Primitive.to_proto(self.project) if ClusterNodeConfig.to_proto(self.node_config): resource.node_config.CopyFrom(ClusterNodeConfig.to_proto(self.node_config)) else: resource.ClearField("node_config") if ClusterReleaseChannel.to_proto(self.release_channel): resource.release_channel.CopyFrom( ClusterReleaseChannel.to_proto(self.release_channel) ) else: resource.ClearField("release_channel") if ClusterWorkloadIdentityConfig.to_proto(self.workload_identity_config): resource.workload_identity_config.CopyFrom( ClusterWorkloadIdentityConfig.to_proto(self.workload_identity_config) ) else: resource.ClearField("workload_identity_config") if ClusterNotificationConfig.to_proto(self.notification_config): resource.notification_config.CopyFrom( ClusterNotificationConfig.to_proto(self.notification_config) ) else: resource.ClearField("notification_config") if ClusterConfidentialNodes.to_proto(self.confidential_nodes): resource.confidential_nodes.CopyFrom( ClusterConfidentialNodes.to_proto(self.confidential_nodes) ) else: resource.ClearField("confidential_nodes") if Primitive.to_proto(self.initial_cluster_version): resource.initial_cluster_version = Primitive.to_proto( self.initial_cluster_version ) if Primitive.to_proto(self.instance_group_urls): resource.instance_group_urls.extend( Primitive.to_proto(self.instance_group_urls) ) return resource class ClusterMasterAuth(object): def __init__( self, username: str = None, password: str = None, client_certificate_config: dict = None, cluster_ca_certificate: str = None, client_certificate: str = None, client_key: str = None, ): self.username = username self.password = password self.client_certificate_config = client_certificate_config self.cluster_ca_certificate = cluster_ca_certificate self.client_certificate = client_certificate self.client_key = client_key @classmethod def to_proto(self, resource): if not resource: return None res = cluster_pb2.ContainerClusterMasterAuth() if Primitive.to_proto(resource.username): res.username = Primitive.to_proto(resource.username) if Primitive.to_proto(resource.password): res.password = Primitive.to_proto(resource.password) if ClusterMasterAuthClientCertificateConfig.to_proto( resource.client_certificate_config ): res.client_certificate_config.CopyFrom( ClusterMasterAuthClientCertificateConfig.to_proto( resource.client_certificate_config ) ) else: res.ClearField("client_certificate_config") if Primitive.to_proto(resource.cluster_ca_certificate): res.cluster_ca_certificate = Primitive.to_proto( resource.cluster_ca_certificate ) if Primitive.to_proto(resource.client_certificate): res.client_certificate = Primitive.to_proto(resource.client_certificate) if Primitive.to_proto(resource.client_key): res.client_key = Primitive.to_proto(resource.client_key) return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterMasterAuth( username=Primitive.from_proto(resource.username), password=Primitive.from_proto(resource.password), client_certificate_config=ClusterMasterAuthClientCertificateConfig.from_proto( resource.client_certificate_config ), cluster_ca_certificate=Primitive.from_proto( resource.cluster_ca_certificate ), client_certificate=Primitive.from_proto(resource.client_certificate), client_key=Primitive.from_proto(resource.client_key), ) class ClusterMasterAuthArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ClusterMasterAuth.to_proto(i) for i in resources] @classmethod def from_proto(self, resources): return [ClusterMasterAuth.from_proto(i) for i in resources] class ClusterMasterAuthClientCertificateConfig(object): def __init__(self, issue_client_certificate: bool = None): self.issue_client_certificate = issue_client_certificate @classmethod def to_proto(self, resource): if not resource: return None res = cluster_pb2.ContainerClusterMasterAuthClientCertificateConfig() if Primitive.to_proto(resource.issue_client_certificate): res.issue_client_certificate = Primitive.to_proto( resource.issue_client_certificate ) return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterMasterAuthClientCertificateConfig( issue_client_certificate=Primitive.from_proto( resource.issue_client_certificate ), ) class ClusterMasterAuthClientCertificateConfigArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ClusterMasterAuthClientCertificateConfig.to_proto(i) for i in resources] @classmethod def from_proto(self, resources): return [ ClusterMasterAuthClientCertificateConfig.from_proto(i) for i in resources ] class ClusterAddonsConfig(object): def __init__( self, http_load_balancing: dict = None, horizontal_pod_autoscaling: dict = None, kubernetes_dashboard: dict = None, network_policy_config: dict = None, cloud_run_config: dict = None, dns_cache_config: dict = None, config_connector_config: dict = None, gce_persistent_disk_csi_driver_config: dict = None, ): self.http_load_balancing = http_load_balancing self.horizontal_pod_autoscaling = horizontal_pod_autoscaling self.kubernetes_dashboard = kubernetes_dashboard self.network_policy_config = network_policy_config self.cloud_run_config = cloud_run_config self.dns_cache_config = dns_cache_config self.config_connector_config = config_connector_config self.gce_persistent_disk_csi_driver_config = ( gce_persistent_disk_csi_driver_config ) @classmethod def to_proto(self, resource): if not resource: return None res = cluster_pb2.ContainerClusterAddonsConfig() if ClusterAddonsConfigHttpLoadBalancing.to_proto(resource.http_load_balancing): res.http_load_balancing.CopyFrom( ClusterAddonsConfigHttpLoadBalancing.to_proto( resource.http_load_balancing ) ) else: res.ClearField("http_load_balancing") if ClusterAddonsConfigHorizontalPodAutoscaling.to_proto( resource.horizontal_pod_autoscaling ): res.horizontal_pod_autoscaling.CopyFrom( ClusterAddonsConfigHorizontalPodAutoscaling.to_proto( resource.horizontal_pod_autoscaling ) ) else: res.ClearField("horizontal_pod_autoscaling") if ClusterAddonsConfigKubernetesDashboard.to_proto( resource.kubernetes_dashboard ): res.kubernetes_dashboard.CopyFrom( ClusterAddonsConfigKubernetesDashboard.to_proto( resource.kubernetes_dashboard ) ) else: res.ClearField("kubernetes_dashboard") if ClusterAddonsConfigNetworkPolicyConfig.to_proto( resource.network_policy_config ): res.network_policy_config.CopyFrom( ClusterAddonsConfigNetworkPolicyConfig.to_proto( resource.network_policy_config ) ) else: res.ClearField("network_policy_config") if ClusterAddonsConfigCloudRunConfig.to_proto(resource.cloud_run_config): res.cloud_run_config.CopyFrom( ClusterAddonsConfigCloudRunConfig.to_proto(resource.cloud_run_config) ) else: res.ClearField("cloud_run_config") if ClusterAddonsConfigDnsCacheConfig.to_proto(resource.dns_cache_config): res.dns_cache_config.CopyFrom( ClusterAddonsConfigDnsCacheConfig.to_proto(resource.dns_cache_config) ) else: res.ClearField("dns_cache_config") if ClusterAddonsConfigConfigConnectorConfig.to_proto( resource.config_connector_config ): res.config_connector_config.CopyFrom( ClusterAddonsConfigConfigConnectorConfig.to_proto( resource.config_connector_config ) ) else: res.ClearField("config_connector_config") if ClusterAddonsConfigGcePersistentDiskCsiDriverConfig.to_proto( resource.gce_persistent_disk_csi_driver_config ): res.gce_persistent_disk_csi_driver_config.CopyFrom( ClusterAddonsConfigGcePersistentDiskCsiDriverConfig.to_proto( resource.gce_persistent_disk_csi_driver_config ) ) else: res.ClearField("gce_persistent_disk_csi_driver_config") return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterAddonsConfig( http_load_balancing=ClusterAddonsConfigHttpLoadBalancing.from_proto( resource.http_load_balancing ), horizontal_pod_autoscaling=ClusterAddonsConfigHorizontalPodAutoscaling.from_proto( resource.horizontal_pod_autoscaling ), kubernetes_dashboard=ClusterAddonsConfigKubernetesDashboard.from_proto( resource.kubernetes_dashboard ), network_policy_config=ClusterAddonsConfigNetworkPolicyConfig.from_proto( resource.network_policy_config ), cloud_run_config=ClusterAddonsConfigCloudRunConfig.from_proto( resource.cloud_run_config ), dns_cache_config=ClusterAddonsConfigDnsCacheConfig.from_proto( resource.dns_cache_config ), config_connector_config=ClusterAddonsConfigConfigConnectorConfig.from_proto( resource.config_connector_config ), gce_persistent_disk_csi_driver_config=ClusterAddonsConfigGcePersistentDiskCsiDriverConfig.from_proto( resource.gce_persistent_disk_csi_driver_config ), ) class ClusterAddonsConfigArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ClusterAddonsConfig.to_proto(i) for i in resources] @classmethod def from_proto(self, resources): return [ClusterAddonsConfig.from_proto(i) for i in resources] class ClusterAddonsConfigHttpLoadBalancing(object): def __init__(self, disabled: bool = None): self.disabled = disabled @classmethod def to_proto(self, resource): if not resource: return None res = cluster_pb2.ContainerClusterAddonsConfigHttpLoadBalancing() if Primitive.to_proto(resource.disabled): res.disabled = Primitive.to_proto(resource.disabled) return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterAddonsConfigHttpLoadBalancing( disabled=Primitive.from_proto(resource.disabled), ) class ClusterAddonsConfigHttpLoadBalancingArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ClusterAddonsConfigHttpLoadBalancing.to_proto(i) for i in resources] @classmethod def from_proto(self, resources): return [ClusterAddonsConfigHttpLoadBalancing.from_proto(i) for i in resources] class ClusterAddonsConfigHorizontalPodAutoscaling(object): def __init__(self, disabled: bool = None): self.disabled = disabled @classmethod def to_proto(self, resource): if not resource: return None res = cluster_pb2.ContainerClusterAddonsConfigHorizontalPodAutoscaling() if Primitive.to_proto(resource.disabled): res.disabled = Primitive.to_proto(resource.disabled) return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterAddonsConfigHorizontalPodAutoscaling( disabled=Primitive.from_proto(resource.disabled), ) class ClusterAddonsConfigHorizontalPodAutoscalingArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ ClusterAddonsConfigHorizontalPodAutoscaling.to_proto(i) for i in resources ] @classmethod def from_proto(self, resources): return [ ClusterAddonsConfigHorizontalPodAutoscaling.from_proto(i) for i in resources ] class ClusterAddonsConfigKubernetesDashboard(object): def __init__(self, disabled: bool = None): self.disabled = disabled @classmethod def to_proto(self, resource): if not resource: return None res = cluster_pb2.ContainerClusterAddonsConfigKubernetesDashboard() if Primitive.to_proto(resource.disabled): res.disabled = Primitive.to_proto(resource.disabled) return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterAddonsConfigKubernetesDashboard( disabled=Primitive.from_proto(resource.disabled), ) class ClusterAddonsConfigKubernetesDashboardArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ClusterAddonsConfigKubernetesDashboard.to_proto(i) for i in resources] @classmethod def from_proto(self, resources): return [ClusterAddonsConfigKubernetesDashboard.from_proto(i) for i in resources] class ClusterAddonsConfigNetworkPolicyConfig(object): def __init__(self, disabled: bool = None): self.disabled = disabled @classmethod def to_proto(self, resource): if not resource: return None res = cluster_pb2.ContainerClusterAddonsConfigNetworkPolicyConfig() if Primitive.to_proto(resource.disabled): res.disabled = Primitive.to_proto(resource.disabled) return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterAddonsConfigNetworkPolicyConfig( disabled=Primitive.from_proto(resource.disabled), ) class ClusterAddonsConfigNetworkPolicyConfigArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ClusterAddonsConfigNetworkPolicyConfig.to_proto(i) for i in resources] @classmethod def from_proto(self, resources): return [ClusterAddonsConfigNetworkPolicyConfig.from_proto(i) for i in resources] class ClusterAddonsConfigCloudRunConfig(object): def __init__(self, disabled: bool = None, load_balancer_type: str = None): self.disabled = disabled self.load_balancer_type = load_balancer_type @classmethod def to_proto(self, resource): if not resource: return None res = cluster_pb2.ContainerClusterAddonsConfigCloudRunConfig() if Primitive.to_proto(resource.disabled): res.disabled = Primitive.to_proto(resource.disabled) if ClusterAddonsConfigCloudRunConfigLoadBalancerTypeEnum.to_proto( resource.load_balancer_type ): res.load_balancer_type = ClusterAddonsConfigCloudRunConfigLoadBalancerTypeEnum.to_proto( resource.load_balancer_type ) return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterAddonsConfigCloudRunConfig( disabled=Primitive.from_proto(resource.disabled), load_balancer_type=ClusterAddonsConfigCloudRunConfigLoadBalancerTypeEnum.from_proto( resource.load_balancer_type ), ) class ClusterAddonsConfigCloudRunConfigArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ClusterAddonsConfigCloudRunConfig.to_proto(i) for i in resources] @classmethod def from_proto(self, resources): return [ClusterAddonsConfigCloudRunConfig.from_proto(i) for i in resources] class ClusterAddonsConfigDnsCacheConfig(object): def __init__(self, enabled: bool = None): self.enabled = enabled @classmethod def to_proto(self, resource): if not resource: return None res = cluster_pb2.ContainerClusterAddonsConfigDnsCacheConfig() if Primitive.to_proto(resource.enabled): res.enabled = Primitive.to_proto(resource.enabled) return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterAddonsConfigDnsCacheConfig( enabled=Primitive.from_proto(resource.enabled), ) class ClusterAddonsConfigDnsCacheConfigArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ClusterAddonsConfigDnsCacheConfig.to_proto(i) for i in resources] @classmethod def from_proto(self, resources): return [ClusterAddonsConfigDnsCacheConfig.from_proto(i) for i in resources] class ClusterAddonsConfigConfigConnectorConfig(object): def __init__(self, enabled: bool = None): self.enabled = enabled @classmethod def to_proto(self, resource): if not resource: return None res = cluster_pb2.ContainerClusterAddonsConfigConfigConnectorConfig() if Primitive.to_proto(resource.enabled): res.enabled = Primitive.to_proto(resource.enabled) return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterAddonsConfigConfigConnectorConfig( enabled=Primitive.from_proto(resource.enabled), ) class ClusterAddonsConfigConfigConnectorConfigArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ClusterAddonsConfigConfigConnectorConfig.to_proto(i) for i in resources] @classmethod def from_proto(self, resources): return [ ClusterAddonsConfigConfigConnectorConfig.from_proto(i) for i in resources ] class ClusterAddonsConfigGcePersistentDiskCsiDriverConfig(object): def __init__(self, enabled: bool = None): self.enabled = enabled @classmethod def to_proto(self, resource): if not resource: return None res = cluster_pb2.ContainerClusterAddonsConfigGcePersistentDiskCsiDriverConfig() if Primitive.to_proto(resource.enabled): res.enabled = Primitive.to_proto(resource.enabled) return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterAddonsConfigGcePersistentDiskCsiDriverConfig( enabled=Primitive.from_proto(resource.enabled), ) class ClusterAddonsConfigGcePersistentDiskCsiDriverConfigArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ ClusterAddonsConfigGcePersistentDiskCsiDriverConfig.to_proto(i) for i in resources ] @classmethod def from_proto(self, resources): return [ ClusterAddonsConfigGcePersistentDiskCsiDriverConfig.from_proto(i) for i in resources ] class ClusterNodePools(object): def __init__( self, name: str = None, config: dict = None, initial_node_count: int = None, locations: list = None, self_link: str = None, version: str = None, instance_group_urls: list = None, status: str = None, status_message: str = None, autoscaling: dict = None, management: dict = None, max_pods_constraint: dict = None, conditions: list = None, pod_ipv4_cidr_size: int = None, upgrade_settings: dict = None, ): self.name = name self.config = config self.initial_node_count = initial_node_count self.locations = locations self.self_link = self_link self.version = version self.instance_group_urls = instance_group_urls self.status = status self.status_message = status_message self.autoscaling = autoscaling self.management = management self.max_pods_constraint = max_pods_constraint self.conditions = conditions self.pod_ipv4_cidr_size = pod_ipv4_cidr_size self.upgrade_settings = upgrade_settings @classmethod def to_proto(self, resource): if not resource: return None res = cluster_pb2.ContainerClusterNodePools() if Primitive.to_proto(resource.name): res.name = Primitive.to_proto(resource.name) if ClusterNodePoolsConfig.to_proto(resource.config): res.config.CopyFrom(ClusterNodePoolsConfig.to_proto(resource.config)) else: res.ClearField("config") if Primitive.to_proto(resource.initial_node_count): res.initial_node_count = Primitive.to_proto(resource.initial_node_count) if Primitive.to_proto(resource.locations): res.locations.extend(Primitive.to_proto(resource.locations)) if Primitive.to_proto(resource.self_link): res.self_link = Primitive.to_proto(resource.self_link) if Primitive.to_proto(resource.version): res.version = Primitive.to_proto(resource.version) if Primitive.to_proto(resource.instance_group_urls): res.instance_group_urls.extend( Primitive.to_proto(resource.instance_group_urls) ) if ClusterNodePoolsStatusEnum.to_proto(resource.status): res.status = ClusterNodePoolsStatusEnum.to_proto(resource.status) if Primitive.to_proto(resource.status_message): res.status_message = Primitive.to_proto(resource.status_message) if ClusterNodePoolsAutoscaling.to_proto(resource.autoscaling): res.autoscaling.CopyFrom( ClusterNodePoolsAutoscaling.to_proto(resource.autoscaling) ) else: res.ClearField("autoscaling") if ClusterNodePoolsManagement.to_proto(resource.management): res.management.CopyFrom( ClusterNodePoolsManagement.to_proto(resource.management) ) else: res.ClearField("management") if ClusterNodePoolsMaxPodsConstraint.to_proto(resource.max_pods_constraint): res.max_pods_constraint.CopyFrom( ClusterNodePoolsMaxPodsConstraint.to_proto(resource.max_pods_constraint) ) else: res.ClearField("max_pods_constraint") if ClusterNodePoolsConditionsArray.to_proto(resource.conditions): res.conditions.extend( ClusterNodePoolsConditionsArray.to_proto(resource.conditions) ) if Primitive.to_proto(resource.pod_ipv4_cidr_size): res.pod_ipv4_cidr_size = Primitive.to_proto(resource.pod_ipv4_cidr_size) if ClusterNodePoolsUpgradeSettings.to_proto(resource.upgrade_settings): res.upgrade_settings.CopyFrom( ClusterNodePoolsUpgradeSettings.to_proto(resource.upgrade_settings) ) else: res.ClearField("upgrade_settings") return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterNodePools( name=Primitive.from_proto(resource.name), config=ClusterNodePoolsConfig.from_proto(resource.config), initial_node_count=Primitive.from_proto(resource.initial_node_count), locations=Primitive.from_proto(resource.locations), self_link=Primitive.from_proto(resource.self_link), version=Primitive.from_proto(resource.version), instance_group_urls=Primitive.from_proto(resource.instance_group_urls), status=ClusterNodePoolsStatusEnum.from_proto(resource.status), status_message=Primitive.from_proto(resource.status_message), autoscaling=ClusterNodePoolsAutoscaling.from_proto(resource.autoscaling), management=ClusterNodePoolsManagement.from_proto(resource.management), max_pods_constraint=ClusterNodePoolsMaxPodsConstraint.from_proto( resource.max_pods_constraint ), conditions=ClusterNodePoolsConditionsArray.from_proto(resource.conditions), pod_ipv4_cidr_size=Primitive.from_proto(resource.pod_ipv4_cidr_size), upgrade_settings=ClusterNodePoolsUpgradeSettings.from_proto( resource.upgrade_settings ), ) class ClusterNodePoolsArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ClusterNodePools.to_proto(i) for i in resources] @classmethod def from_proto(self, resources): return [ClusterNodePools.from_proto(i) for i in resources] class ClusterNodePoolsConfig(object): def __init__( self, machine_type: str = None, disk_size_gb: int = None, oauth_scopes: list = None, service_account: str = None, metadata: dict = None, image_type: str = None, labels: dict = None, local_ssd_count: int = None, tags: list = None, preemptible: bool = None, accelerators: list = None, disk_type: str = None, min_cpu_platform: str = None, workload_metadata_config: dict = None, taints: list = None, sandbox_config: dict = None, node_group: str = None, reservation_affinity: dict = None, shielded_instance_config: dict = None, linux_node_config: dict = None, kubelet_config: dict = None, boot_disk_kms_key: str = None, ): self.machine_type = machine_type self.disk_size_gb = disk_size_gb self.oauth_scopes = oauth_scopes self.service_account = service_account self.metadata = metadata self.image_type = image_type self.labels = labels self.local_ssd_count = local_ssd_count self.tags = tags self.preemptible = preemptible self.accelerators = accelerators self.disk_type = disk_type self.min_cpu_platform = min_cpu_platform self.workload_metadata_config = workload_metadata_config self.taints = taints self.sandbox_config = sandbox_config self.node_group = node_group self.reservation_affinity = reservation_affinity self.shielded_instance_config = shielded_instance_config self.linux_node_config = linux_node_config self.kubelet_config = kubelet_config self.boot_disk_kms_key = boot_disk_kms_key @classmethod def to_proto(self, resource): if not resource: return None res = cluster_pb2.ContainerClusterNodePoolsConfig() if Primitive.to_proto(resource.machine_type): res.machine_type = Primitive.to_proto(resource.machine_type) if Primitive.to_proto(resource.disk_size_gb): res.disk_size_gb = Primitive.to_proto(resource.disk_size_gb) if Primitive.to_proto(resource.oauth_scopes): res.oauth_scopes.extend(Primitive.to_proto(resource.oauth_scopes)) if Primitive.to_proto(resource.service_account): res.service_account = Primitive.to_proto(resource.service_account) if Primitive.to_proto(resource.metadata): res.metadata = Primitive.to_proto(resource.metadata) if Primitive.to_proto(resource.image_type): res.image_type = Primitive.to_proto(resource.image_type) if Primitive.to_proto(resource.labels): res.labels = Primitive.to_proto(resource.labels) if Primitive.to_proto(resource.local_ssd_count): res.local_ssd_count = Primitive.to_proto(resource.local_ssd_count) if Primitive.to_proto(resource.tags): res.tags.extend(Primitive.to_proto(resource.tags)) if Primitive.to_proto(resource.preemptible): res.preemptible = Primitive.to_proto(resource.preemptible) if ClusterNodePoolsConfigAcceleratorsArray.to_proto(resource.accelerators): res.accelerators.extend( ClusterNodePoolsConfigAcceleratorsArray.to_proto(resource.accelerators) ) if Primitive.to_proto(resource.disk_type): res.disk_type = Primitive.to_proto(resource.disk_type) if Primitive.to_proto(resource.min_cpu_platform): res.min_cpu_platform = Primitive.to_proto(resource.min_cpu_platform) if ClusterNodePoolsConfigWorkloadMetadataConfig.to_proto( resource.workload_metadata_config ): res.workload_metadata_config.CopyFrom( ClusterNodePoolsConfigWorkloadMetadataConfig.to_proto( resource.workload_metadata_config ) ) else: res.ClearField("workload_metadata_config") if ClusterNodePoolsConfigTaintsArray.to_proto(resource.taints): res.taints.extend( ClusterNodePoolsConfigTaintsArray.to_proto(resource.taints) ) if ClusterNodePoolsConfigSandboxConfig.to_proto(resource.sandbox_config): res.sandbox_config.CopyFrom( ClusterNodePoolsConfigSandboxConfig.to_proto(resource.sandbox_config) ) else: res.ClearField("sandbox_config") if Primitive.to_proto(resource.node_group): res.node_group = Primitive.to_proto(resource.node_group) if ClusterNodePoolsConfigReservationAffinity.to_proto( resource.reservation_affinity ): res.reservation_affinity.CopyFrom( ClusterNodePoolsConfigReservationAffinity.to_proto( resource.reservation_affinity ) ) else: res.ClearField("reservation_affinity") if ClusterNodePoolsConfigShieldedInstanceConfig.to_proto( resource.shielded_instance_config ): res.shielded_instance_config.CopyFrom( ClusterNodePoolsConfigShieldedInstanceConfig.to_proto( resource.shielded_instance_config ) ) else: res.ClearField("shielded_instance_config") if ClusterNodePoolsConfigLinuxNodeConfig.to_proto(resource.linux_node_config): res.linux_node_config.CopyFrom( ClusterNodePoolsConfigLinuxNodeConfig.to_proto( resource.linux_node_config ) ) else: res.ClearField("linux_node_config") if ClusterNodePoolsConfigKubeletConfig.to_proto(resource.kubelet_config): res.kubelet_config.CopyFrom( ClusterNodePoolsConfigKubeletConfig.to_proto(resource.kubelet_config) ) else: res.ClearField("kubelet_config") if Primitive.to_proto(resource.boot_disk_kms_key): res.boot_disk_kms_key = Primitive.to_proto(resource.boot_disk_kms_key) return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterNodePoolsConfig( machine_type=Primitive.from_proto(resource.machine_type), disk_size_gb=Primitive.from_proto(resource.disk_size_gb), oauth_scopes=Primitive.from_proto(resource.oauth_scopes), service_account=Primitive.from_proto(resource.service_account), metadata=Primitive.from_proto(resource.metadata), image_type=Primitive.from_proto(resource.image_type), labels=Primitive.from_proto(resource.labels), local_ssd_count=Primitive.from_proto(resource.local_ssd_count), tags=Primitive.from_proto(resource.tags), preemptible=Primitive.from_proto(resource.preemptible), accelerators=ClusterNodePoolsConfigAcceleratorsArray.from_proto( resource.accelerators ), disk_type=Primitive.from_proto(resource.disk_type), min_cpu_platform=Primitive.from_proto(resource.min_cpu_platform), workload_metadata_config=ClusterNodePoolsConfigWorkloadMetadataConfig.from_proto( resource.workload_metadata_config ), taints=ClusterNodePoolsConfigTaintsArray.from_proto(resource.taints), sandbox_config=ClusterNodePoolsConfigSandboxConfig.from_proto( resource.sandbox_config ), node_group=Primitive.from_proto(resource.node_group), reservation_affinity=ClusterNodePoolsConfigReservationAffinity.from_proto( resource.reservation_affinity ), shielded_instance_config=ClusterNodePoolsConfigShieldedInstanceConfig.from_proto( resource.shielded_instance_config ), linux_node_config=ClusterNodePoolsConfigLinuxNodeConfig.from_proto( resource.linux_node_config ), kubelet_config=ClusterNodePoolsConfigKubeletConfig.from_proto( resource.kubelet_config ), boot_disk_kms_key=Primitive.from_proto(resource.boot_disk_kms_key), ) class ClusterNodePoolsConfigArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ClusterNodePoolsConfig.to_proto(i) for i in resources] @classmethod def from_proto(self, resources): return [ClusterNodePoolsConfig.from_proto(i) for i in resources] class ClusterNodePoolsConfigAccelerators(object): def __init__(self, accelerator_count: int = None, accelerator_type: str = None): self.accelerator_count = accelerator_count self.accelerator_type = accelerator_type @classmethod def to_proto(self, resource): if not resource: return None res = cluster_pb2.ContainerClusterNodePoolsConfigAccelerators() if Primitive.to_proto(resource.accelerator_count): res.accelerator_count = Primitive.to_proto(resource.accelerator_count) if Primitive.to_proto(resource.accelerator_type): res.accelerator_type = Primitive.to_proto(resource.accelerator_type) return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterNodePoolsConfigAccelerators( accelerator_count=Primitive.from_proto(resource.accelerator_count), accelerator_type=Primitive.from_proto(resource.accelerator_type), ) class ClusterNodePoolsConfigAcceleratorsArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ClusterNodePoolsConfigAccelerators.to_proto(i) for i in resources] @classmethod def from_proto(self, resources): return [ClusterNodePoolsConfigAccelerators.from_proto(i) for i in resources] class ClusterNodePoolsConfigWorkloadMetadataConfig(object): def __init__(self, mode: str = None): self.mode = mode @classmethod def to_proto(self, resource): if not resource: return None res = cluster_pb2.ContainerClusterNodePoolsConfigWorkloadMetadataConfig() if ClusterNodePoolsConfigWorkloadMetadataConfigModeEnum.to_proto(resource.mode): res.mode = ClusterNodePoolsConfigWorkloadMetadataConfigModeEnum.to_proto( resource.mode ) return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterNodePoolsConfigWorkloadMetadataConfig( mode=ClusterNodePoolsConfigWorkloadMetadataConfigModeEnum.from_proto( resource.mode ), ) class ClusterNodePoolsConfigWorkloadMetadataConfigArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ ClusterNodePoolsConfigWorkloadMetadataConfig.to_proto(i) for i in resources ] @classmethod def from_proto(self, resources): return [ ClusterNodePoolsConfigWorkloadMetadataConfig.from_proto(i) for i in resources ] class ClusterNodePoolsConfigTaints(object): def __init__(self, key: str = None, value: str = None, effect: str = None): self.key = key self.value = value self.effect = effect @classmethod def to_proto(self, resource): if not resource: return None res = cluster_pb2.ContainerClusterNodePoolsConfigTaints() if Primitive.to_proto(resource.key): res.key = Primitive.to_proto(resource.key) if Primitive.to_proto(resource.value): res.value = Primitive.to_proto(resource.value) if ClusterNodePoolsConfigTaintsEffectEnum.to_proto(resource.effect): res.effect = ClusterNodePoolsConfigTaintsEffectEnum.to_proto( resource.effect ) return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterNodePoolsConfigTaints( key=Primitive.from_proto(resource.key), value=Primitive.from_proto(resource.value), effect=ClusterNodePoolsConfigTaintsEffectEnum.from_proto(resource.effect), ) class ClusterNodePoolsConfigTaintsArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ClusterNodePoolsConfigTaints.to_proto(i) for i in resources] @classmethod def from_proto(self, resources): return [ClusterNodePoolsConfigTaints.from_proto(i) for i in resources] class ClusterNodePoolsConfigSandboxConfig(object): def __init__(self, type: str = None): self.type = type @classmethod def to_proto(self, resource): if not resource: return None res = cluster_pb2.ContainerClusterNodePoolsConfigSandboxConfig() if ClusterNodePoolsConfigSandboxConfigTypeEnum.to_proto(resource.type): res.type = ClusterNodePoolsConfigSandboxConfigTypeEnum.to_proto( resource.type ) return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterNodePoolsConfigSandboxConfig( type=ClusterNodePoolsConfigSandboxConfigTypeEnum.from_proto(resource.type), ) class ClusterNodePoolsConfigSandboxConfigArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ClusterNodePoolsConfigSandboxConfig.to_proto(i) for i in resources] @classmethod def from_proto(self, resources): return [ClusterNodePoolsConfigSandboxConfig.from_proto(i) for i in resources] class ClusterNodePoolsConfigReservationAffinity(object): def __init__( self, consume_reservation_type: str = None, key: str = None, values: list = None ): self.consume_reservation_type = consume_reservation_type self.key = key self.values = values @classmethod def to_proto(self, resource): if not resource: return None res = cluster_pb2.ContainerClusterNodePoolsConfigReservationAffinity() if ClusterNodePoolsConfigReservationAffinityConsumeReservationTypeEnum.to_proto( resource.consume_reservation_type ): res.consume_reservation_type = ClusterNodePoolsConfigReservationAffinityConsumeReservationTypeEnum.to_proto( resource.consume_reservation_type ) if Primitive.to_proto(resource.key): res.key = Primitive.to_proto(resource.key) if Primitive.to_proto(resource.values): res.values.extend(Primitive.to_proto(resource.values)) return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterNodePoolsConfigReservationAffinity( consume_reservation_type=ClusterNodePoolsConfigReservationAffinityConsumeReservationTypeEnum.from_proto( resource.consume_reservation_type ), key=Primitive.from_proto(resource.key), values=Primitive.from_proto(resource.values), ) class ClusterNodePoolsConfigReservationAffinityArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ ClusterNodePoolsConfigReservationAffinity.to_proto(i) for i in resources ] @classmethod def from_proto(self, resources): return [ ClusterNodePoolsConfigReservationAffinity.from_proto(i) for i in resources ] class ClusterNodePoolsConfigShieldedInstanceConfig(object): def __init__( self, enable_secure_boot: bool = None, enable_integrity_monitoring: bool = None ): self.enable_secure_boot = enable_secure_boot self.enable_integrity_monitoring = enable_integrity_monitoring @classmethod def to_proto(self, resource): if not resource: return None res = cluster_pb2.ContainerClusterNodePoolsConfigShieldedInstanceConfig() if Primitive.to_proto(resource.enable_secure_boot): res.enable_secure_boot = Primitive.to_proto(resource.enable_secure_boot) if Primitive.to_proto(resource.enable_integrity_monitoring): res.enable_integrity_monitoring = Primitive.to_proto( resource.enable_integrity_monitoring ) return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterNodePoolsConfigShieldedInstanceConfig( enable_secure_boot=Primitive.from_proto(resource.enable_secure_boot), enable_integrity_monitoring=Primitive.from_proto( resource.enable_integrity_monitoring ), ) class ClusterNodePoolsConfigShieldedInstanceConfigArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ ClusterNodePoolsConfigShieldedInstanceConfig.to_proto(i) for i in resources ] @classmethod def from_proto(self, resources): return [ ClusterNodePoolsConfigShieldedInstanceConfig.from_proto(i) for i in resources ] class ClusterNodePoolsConfigLinuxNodeConfig(object): def __init__(self, sysctls: dict = None): self.sysctls = sysctls @classmethod def to_proto(self, resource): if not resource: return None res = cluster_pb2.ContainerClusterNodePoolsConfigLinuxNodeConfig() if Primitive.to_proto(resource.sysctls): res.sysctls = Primitive.to_proto(resource.sysctls) return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterNodePoolsConfigLinuxNodeConfig( sysctls=Primitive.from_proto(resource.sysctls), ) class ClusterNodePoolsConfigLinuxNodeConfigArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ClusterNodePoolsConfigLinuxNodeConfig.to_proto(i) for i in resources] @classmethod def from_proto(self, resources): return [ClusterNodePoolsConfigLinuxNodeConfig.from_proto(i) for i in resources] class ClusterNodePoolsConfigKubeletConfig(object): def __init__( self, cpu_manager_policy: str = None, cpu_cfs_quota: bool = None, cpu_cfs_quota_period: str = None, ): self.cpu_manager_policy = cpu_manager_policy self.cpu_cfs_quota = cpu_cfs_quota self.cpu_cfs_quota_period = cpu_cfs_quota_period @classmethod def to_proto(self, resource): if not resource: return None res = cluster_pb2.ContainerClusterNodePoolsConfigKubeletConfig() if Primitive.to_proto(resource.cpu_manager_policy): res.cpu_manager_policy = Primitive.to_proto(resource.cpu_manager_policy) if Primitive.to_proto(resource.cpu_cfs_quota): res.cpu_cfs_quota = Primitive.to_proto(resource.cpu_cfs_quota) if Primitive.to_proto(resource.cpu_cfs_quota_period): res.cpu_cfs_quota_period = Primitive.to_proto(resource.cpu_cfs_quota_period) return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterNodePoolsConfigKubeletConfig( cpu_manager_policy=Primitive.from_proto(resource.cpu_manager_policy), cpu_cfs_quota=Primitive.from_proto(resource.cpu_cfs_quota), cpu_cfs_quota_period=Primitive.from_proto(resource.cpu_cfs_quota_period), ) class ClusterNodePoolsConfigKubeletConfigArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ClusterNodePoolsConfigKubeletConfig.to_proto(i) for i in resources] @classmethod def from_proto(self, resources): return [ClusterNodePoolsConfigKubeletConfig.from_proto(i) for i in resources] class ClusterNodePoolsAutoscaling(object): def __init__( self, enabled: bool = None, min_node_count: int = None, max_node_count: int = None, autoprovisioned: bool = None, ): self.enabled = enabled self.min_node_count = min_node_count self.max_node_count = max_node_count self.autoprovisioned = autoprovisioned @classmethod def to_proto(self, resource): if not resource: return None res = cluster_pb2.ContainerClusterNodePoolsAutoscaling() if Primitive.to_proto(resource.enabled): res.enabled = Primitive.to_proto(resource.enabled) if Primitive.to_proto(resource.min_node_count): res.min_node_count = Primitive.to_proto(resource.min_node_count) if Primitive.to_proto(resource.max_node_count): res.max_node_count = Primitive.to_proto(resource.max_node_count) if Primitive.to_proto(resource.autoprovisioned): res.autoprovisioned = Primitive.to_proto(resource.autoprovisioned) return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterNodePoolsAutoscaling( enabled=Primitive.from_proto(resource.enabled), min_node_count=Primitive.from_proto(resource.min_node_count), max_node_count=Primitive.from_proto(resource.max_node_count), autoprovisioned=Primitive.from_proto(resource.autoprovisioned), ) class ClusterNodePoolsAutoscalingArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ClusterNodePoolsAutoscaling.to_proto(i) for i in resources] @classmethod def from_proto(self, resources): return [ClusterNodePoolsAutoscaling.from_proto(i) for i in resources] class ClusterNodePoolsManagement(object): def __init__( self, auto_upgrade: bool = None, auto_repair: bool = None, upgrade_options: dict = None, ): self.auto_upgrade = auto_upgrade self.auto_repair = auto_repair self.upgrade_options = upgrade_options @classmethod def to_proto(self, resource): if not resource: return None res = cluster_pb2.ContainerClusterNodePoolsManagement() if Primitive.to_proto(resource.auto_upgrade): res.auto_upgrade = Primitive.to_proto(resource.auto_upgrade) if Primitive.to_proto(resource.auto_repair): res.auto_repair = Primitive.to_proto(resource.auto_repair) if ClusterNodePoolsManagementUpgradeOptions.to_proto(resource.upgrade_options): res.upgrade_options.CopyFrom( ClusterNodePoolsManagementUpgradeOptions.to_proto( resource.upgrade_options ) ) else: res.ClearField("upgrade_options") return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterNodePoolsManagement( auto_upgrade=Primitive.from_proto(resource.auto_upgrade), auto_repair=Primitive.from_proto(resource.auto_repair), upgrade_options=ClusterNodePoolsManagementUpgradeOptions.from_proto( resource.upgrade_options ), ) class ClusterNodePoolsManagementArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ClusterNodePoolsManagement.to_proto(i) for i in resources] @classmethod def from_proto(self, resources): return [ClusterNodePoolsManagement.from_proto(i) for i in resources] class ClusterNodePoolsManagementUpgradeOptions(object): def __init__(self, auto_upgrade_start_time: str = None, description: str = None): self.auto_upgrade_start_time = auto_upgrade_start_time self.description = description @classmethod def to_proto(self, resource): if not resource: return None res = cluster_pb2.ContainerClusterNodePoolsManagementUpgradeOptions() if Primitive.to_proto(resource.auto_upgrade_start_time): res.auto_upgrade_start_time = Primitive.to_proto( resource.auto_upgrade_start_time ) if Primitive.to_proto(resource.description): res.description = Primitive.to_proto(resource.description) return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterNodePoolsManagementUpgradeOptions( auto_upgrade_start_time=Primitive.from_proto( resource.auto_upgrade_start_time ), description=Primitive.from_proto(resource.description), ) class ClusterNodePoolsManagementUpgradeOptionsArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ClusterNodePoolsManagementUpgradeOptions.to_proto(i) for i in resources] @classmethod def from_proto(self, resources): return [ ClusterNodePoolsManagementUpgradeOptions.from_proto(i) for i in resources ] class ClusterNodePoolsMaxPodsConstraint(object): def __init__(self, max_pods_per_node: int = None): self.max_pods_per_node = max_pods_per_node @classmethod def to_proto(self, resource): if not resource: return None res = cluster_pb2.ContainerClusterNodePoolsMaxPodsConstraint() if Primitive.to_proto(resource.max_pods_per_node): res.max_pods_per_node = Primitive.to_proto(resource.max_pods_per_node) return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterNodePoolsMaxPodsConstraint( max_pods_per_node=Primitive.from_proto(resource.max_pods_per_node), ) class ClusterNodePoolsMaxPodsConstraintArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ClusterNodePoolsMaxPodsConstraint.to_proto(i) for i in resources] @classmethod def from_proto(self, resources): return [ClusterNodePoolsMaxPodsConstraint.from_proto(i) for i in resources] class ClusterNodePoolsConditions(object): def __init__( self, code: str = None, message: str = None, canonical_code: str = None ): self.code = code self.message = message self.canonical_code = canonical_code @classmethod def to_proto(self, resource): if not resource: return None res = cluster_pb2.ContainerClusterNodePoolsConditions() if ClusterNodePoolsConditionsCodeEnum.to_proto(resource.code): res.code = ClusterNodePoolsConditionsCodeEnum.to_proto(resource.code) if Primitive.to_proto(resource.message): res.message = Primitive.to_proto(resource.message) if ClusterNodePoolsConditionsCanonicalCodeEnum.to_proto( resource.canonical_code ): res.canonical_code = ClusterNodePoolsConditionsCanonicalCodeEnum.to_proto( resource.canonical_code ) return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterNodePoolsConditions( code=ClusterNodePoolsConditionsCodeEnum.from_proto(resource.code), message=Primitive.from_proto(resource.message), canonical_code=ClusterNodePoolsConditionsCanonicalCodeEnum.from_proto( resource.canonical_code ), ) class ClusterNodePoolsConditionsArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ClusterNodePoolsConditions.to_proto(i) for i in resources] @classmethod def from_proto(self, resources): return [ClusterNodePoolsConditions.from_proto(i) for i in resources] class ClusterNodePoolsUpgradeSettings(object): def __init__(self, max_surge: int = None, max_unavailable: int = None): self.max_surge = max_surge self.max_unavailable = max_unavailable @classmethod def to_proto(self, resource): if not resource: return None res = cluster_pb2.ContainerClusterNodePoolsUpgradeSettings() if Primitive.to_proto(resource.max_surge): res.max_surge = Primitive.to_proto(resource.max_surge) if Primitive.to_proto(resource.max_unavailable): res.max_unavailable = Primitive.to_proto(resource.max_unavailable) return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterNodePoolsUpgradeSettings( max_surge=Primitive.from_proto(resource.max_surge), max_unavailable=Primitive.from_proto(resource.max_unavailable), ) class ClusterNodePoolsUpgradeSettingsArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ClusterNodePoolsUpgradeSettings.to_proto(i) for i in resources] @classmethod def from_proto(self, resources): return [ClusterNodePoolsUpgradeSettings.from_proto(i) for i in resources] class ClusterLegacyAbac(object): def __init__(self, enabled: bool = None): self.enabled = enabled @classmethod def to_proto(self, resource): if not resource: return None res = cluster_pb2.ContainerClusterLegacyAbac() if Primitive.to_proto(resource.enabled): res.enabled = Primitive.to_proto(resource.enabled) return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterLegacyAbac(enabled=Primitive.from_proto(resource.enabled),) class ClusterLegacyAbacArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ClusterLegacyAbac.to_proto(i) for i in resources] @classmethod def from_proto(self, resources): return [ClusterLegacyAbac.from_proto(i) for i in resources] class ClusterNetworkPolicy(object): def __init__(self, provider: str = None, enabled: bool = None): self.provider = provider self.enabled = enabled @classmethod def to_proto(self, resource): if not resource: return None res = cluster_pb2.ContainerClusterNetworkPolicy() if ClusterNetworkPolicyProviderEnum.to_proto(resource.provider): res.provider = ClusterNetworkPolicyProviderEnum.to_proto(resource.provider) if Primitive.to_proto(resource.enabled): res.enabled = Primitive.to_proto(resource.enabled) return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterNetworkPolicy( provider=ClusterNetworkPolicyProviderEnum.from_proto(resource.provider), enabled=Primitive.from_proto(resource.enabled), ) class ClusterNetworkPolicyArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ClusterNetworkPolicy.to_proto(i) for i in resources] @classmethod def from_proto(self, resources): return [ClusterNetworkPolicy.from_proto(i) for i in resources] class ClusterIPAllocationPolicy(object): def __init__( self, use_ip_aliases: bool = None, create_subnetwork: bool = None, subnetwork_name: str = None, cluster_secondary_range_name: str = None, services_secondary_range_name: str = None, cluster_ipv4_cidr_block: str = None, node_ipv4_cidr_block: str = None, services_ipv4_cidr_block: str = None, tpu_ipv4_cidr_block: str = None, cluster_ipv4_cidr: str = None, node_ipv4_cidr: str = None, services_ipv4_cidr: str = None, use_routes: bool = None, ): self.use_ip_aliases = use_ip_aliases self.create_subnetwork = create_subnetwork self.subnetwork_name = subnetwork_name self.cluster_secondary_range_name = cluster_secondary_range_name self.services_secondary_range_name = services_secondary_range_name self.cluster_ipv4_cidr_block = cluster_ipv4_cidr_block self.node_ipv4_cidr_block = node_ipv4_cidr_block self.services_ipv4_cidr_block = services_ipv4_cidr_block self.tpu_ipv4_cidr_block = tpu_ipv4_cidr_block self.cluster_ipv4_cidr = cluster_ipv4_cidr self.node_ipv4_cidr = node_ipv4_cidr self.services_ipv4_cidr = services_ipv4_cidr self.use_routes = use_routes @classmethod def to_proto(self, resource): if not resource: return None res = cluster_pb2.ContainerClusterIPAllocationPolicy() if Primitive.to_proto(resource.use_ip_aliases): res.use_ip_aliases = Primitive.to_proto(resource.use_ip_aliases) if Primitive.to_proto(resource.create_subnetwork): res.create_subnetwork = Primitive.to_proto(resource.create_subnetwork) if Primitive.to_proto(resource.subnetwork_name): res.subnetwork_name = Primitive.to_proto(resource.subnetwork_name) if Primitive.to_proto(resource.cluster_secondary_range_name): res.cluster_secondary_range_name = Primitive.to_proto( resource.cluster_secondary_range_name ) if Primitive.to_proto(resource.services_secondary_range_name): res.services_secondary_range_name = Primitive.to_proto( resource.services_secondary_range_name ) if Primitive.to_proto(resource.cluster_ipv4_cidr_block): res.cluster_ipv4_cidr_block = Primitive.to_proto( resource.cluster_ipv4_cidr_block ) if Primitive.to_proto(resource.node_ipv4_cidr_block): res.node_ipv4_cidr_block = Primitive.to_proto(resource.node_ipv4_cidr_block) if Primitive.to_proto(resource.services_ipv4_cidr_block): res.services_ipv4_cidr_block = Primitive.to_proto( resource.services_ipv4_cidr_block ) if Primitive.to_proto(resource.tpu_ipv4_cidr_block): res.tpu_ipv4_cidr_block = Primitive.to_proto(resource.tpu_ipv4_cidr_block) if Primitive.to_proto(resource.cluster_ipv4_cidr): res.cluster_ipv4_cidr = Primitive.to_proto(resource.cluster_ipv4_cidr) if Primitive.to_proto(resource.node_ipv4_cidr): res.node_ipv4_cidr = Primitive.to_proto(resource.node_ipv4_cidr) if Primitive.to_proto(resource.services_ipv4_cidr): res.services_ipv4_cidr = Primitive.to_proto(resource.services_ipv4_cidr) if Primitive.to_proto(resource.use_routes): res.use_routes = Primitive.to_proto(resource.use_routes) return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterIPAllocationPolicy( use_ip_aliases=Primitive.from_proto(resource.use_ip_aliases), create_subnetwork=Primitive.from_proto(resource.create_subnetwork), subnetwork_name=Primitive.from_proto(resource.subnetwork_name), cluster_secondary_range_name=Primitive.from_proto( resource.cluster_secondary_range_name ), services_secondary_range_name=Primitive.from_proto( resource.services_secondary_range_name ), cluster_ipv4_cidr_block=Primitive.from_proto( resource.cluster_ipv4_cidr_block ), node_ipv4_cidr_block=Primitive.from_proto(resource.node_ipv4_cidr_block), services_ipv4_cidr_block=Primitive.from_proto( resource.services_ipv4_cidr_block ), tpu_ipv4_cidr_block=Primitive.from_proto(resource.tpu_ipv4_cidr_block), cluster_ipv4_cidr=Primitive.from_proto(resource.cluster_ipv4_cidr), node_ipv4_cidr=Primitive.from_proto(resource.node_ipv4_cidr), services_ipv4_cidr=Primitive.from_proto(resource.services_ipv4_cidr), use_routes=Primitive.from_proto(resource.use_routes), ) class ClusterIPAllocationPolicyArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ClusterIPAllocationPolicy.to_proto(i) for i in resources] @classmethod def from_proto(self, resources): return [ClusterIPAllocationPolicy.from_proto(i) for i in resources] class ClusterMasterAuthorizedNetworksConfig(object): def __init__(self, enabled: bool = None, cidr_blocks: list = None): self.enabled = enabled self.cidr_blocks = cidr_blocks @classmethod def to_proto(self, resource): if not resource: return None res = cluster_pb2.ContainerClusterMasterAuthorizedNetworksConfig() if Primitive.to_proto(resource.enabled): res.enabled = Primitive.to_proto(resource.enabled) if ClusterMasterAuthorizedNetworksConfigCidrBlocksArray.to_proto( resource.cidr_blocks ): res.cidr_blocks.extend( ClusterMasterAuthorizedNetworksConfigCidrBlocksArray.to_proto( resource.cidr_blocks ) ) return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterMasterAuthorizedNetworksConfig( enabled=Primitive.from_proto(resource.enabled), cidr_blocks=ClusterMasterAuthorizedNetworksConfigCidrBlocksArray.from_proto( resource.cidr_blocks ), ) class ClusterMasterAuthorizedNetworksConfigArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ClusterMasterAuthorizedNetworksConfig.to_proto(i) for i in resources] @classmethod def from_proto(self, resources): return [ClusterMasterAuthorizedNetworksConfig.from_proto(i) for i in resources] class ClusterMasterAuthorizedNetworksConfigCidrBlocks(object): def __init__(self, display_name: str = None, cidr_block: str = None): self.display_name = display_name self.cidr_block = cidr_block @classmethod def to_proto(self, resource): if not resource: return None res = cluster_pb2.ContainerClusterMasterAuthorizedNetworksConfigCidrBlocks() if Primitive.to_proto(resource.display_name): res.display_name = Primitive.to_proto(resource.display_name) if Primitive.to_proto(resource.cidr_block): res.cidr_block = Primitive.to_proto(resource.cidr_block) return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterMasterAuthorizedNetworksConfigCidrBlocks( display_name=Primitive.from_proto(resource.display_name), cidr_block=Primitive.from_proto(resource.cidr_block), ) class ClusterMasterAuthorizedNetworksConfigCidrBlocksArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ ClusterMasterAuthorizedNetworksConfigCidrBlocks.to_proto(i) for i in resources ] @classmethod def from_proto(self, resources): return [ ClusterMasterAuthorizedNetworksConfigCidrBlocks.from_proto(i) for i in resources ] class ClusterBinaryAuthorization(object): def __init__(self, enabled: bool = None): self.enabled = enabled @classmethod def to_proto(self, resource): if not resource: return None res = cluster_pb2.ContainerClusterBinaryAuthorization() if Primitive.to_proto(resource.enabled): res.enabled = Primitive.to_proto(resource.enabled) return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterBinaryAuthorization( enabled=Primitive.from_proto(resource.enabled), ) class ClusterBinaryAuthorizationArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ClusterBinaryAuthorization.to_proto(i) for i in resources] @classmethod def from_proto(self, resources): return [ClusterBinaryAuthorization.from_proto(i) for i in resources] class ClusterAutoscaling(object): def __init__( self, enable_node_autoprovisioning: bool = None, resource_limits: list = None, autoprovisioning_node_pool_defaults: dict = None, autoprovisioning_locations: list = None, ): self.enable_node_autoprovisioning = enable_node_autoprovisioning self.resource_limits = resource_limits self.autoprovisioning_node_pool_defaults = autoprovisioning_node_pool_defaults self.autoprovisioning_locations = autoprovisioning_locations @classmethod def to_proto(self, resource): if not resource: return None res = cluster_pb2.ContainerClusterAutoscaling() if Primitive.to_proto(resource.enable_node_autoprovisioning): res.enable_node_autoprovisioning = Primitive.to_proto( resource.enable_node_autoprovisioning ) if ClusterAutoscalingResourceLimitsArray.to_proto(resource.resource_limits): res.resource_limits.extend( ClusterAutoscalingResourceLimitsArray.to_proto(resource.resource_limits) ) if ClusterAutoscalingAutoprovisioningNodePoolDefaults.to_proto( resource.autoprovisioning_node_pool_defaults ): res.autoprovisioning_node_pool_defaults.CopyFrom( ClusterAutoscalingAutoprovisioningNodePoolDefaults.to_proto( resource.autoprovisioning_node_pool_defaults ) ) else: res.ClearField("autoprovisioning_node_pool_defaults") if Primitive.to_proto(resource.autoprovisioning_locations): res.autoprovisioning_locations.extend( Primitive.to_proto(resource.autoprovisioning_locations) ) return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterAutoscaling( enable_node_autoprovisioning=Primitive.from_proto( resource.enable_node_autoprovisioning ), resource_limits=ClusterAutoscalingResourceLimitsArray.from_proto( resource.resource_limits ), autoprovisioning_node_pool_defaults=ClusterAutoscalingAutoprovisioningNodePoolDefaults.from_proto( resource.autoprovisioning_node_pool_defaults ), autoprovisioning_locations=Primitive.from_proto( resource.autoprovisioning_locations ), ) class ClusterAutoscalingArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ClusterAutoscaling.to_proto(i) for i in resources] @classmethod def from_proto(self, resources): return [ClusterAutoscaling.from_proto(i) for i in resources] class ClusterAutoscalingResourceLimits(object): def __init__( self, resource_type: str = None, minimum: int = None, maximum: int = None ): self.resource_type = resource_type self.minimum = minimum self.maximum = maximum @classmethod def to_proto(self, resource): if not resource: return None res = cluster_pb2.ContainerClusterAutoscalingResourceLimits() if Primitive.to_proto(resource.resource_type): res.resource_type = Primitive.to_proto(resource.resource_type) if Primitive.to_proto(resource.minimum): res.minimum = Primitive.to_proto(resource.minimum) if Primitive.to_proto(resource.maximum): res.maximum = Primitive.to_proto(resource.maximum) return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterAutoscalingResourceLimits( resource_type=Primitive.from_proto(resource.resource_type), minimum=Primitive.from_proto(resource.minimum), maximum=Primitive.from_proto(resource.maximum), ) class ClusterAutoscalingResourceLimitsArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ClusterAutoscalingResourceLimits.to_proto(i) for i in resources] @classmethod def from_proto(self, resources): return [ClusterAutoscalingResourceLimits.from_proto(i) for i in resources] class ClusterAutoscalingAutoprovisioningNodePoolDefaults(object): def __init__( self, oauth_scopes: list = None, service_account: str = None, upgrade_settings: dict = None, management: dict = None, min_cpu_platform: str = None, disk_size_gb: int = None, disk_type: str = None, shielded_instance_config: dict = None, boot_disk_kms_key: str = None, ): self.oauth_scopes = oauth_scopes self.service_account = service_account self.upgrade_settings = upgrade_settings self.management = management self.min_cpu_platform = min_cpu_platform self.disk_size_gb = disk_size_gb self.disk_type = disk_type self.shielded_instance_config = shielded_instance_config self.boot_disk_kms_key = boot_disk_kms_key @classmethod def to_proto(self, resource): if not resource: return None res = cluster_pb2.ContainerClusterAutoscalingAutoprovisioningNodePoolDefaults() if Primitive.to_proto(resource.oauth_scopes): res.oauth_scopes.extend(Primitive.to_proto(resource.oauth_scopes)) if Primitive.to_proto(resource.service_account): res.service_account = Primitive.to_proto(resource.service_account) if ClusterAutoscalingAutoprovisioningNodePoolDefaultsUpgradeSettings.to_proto( resource.upgrade_settings ): res.upgrade_settings.CopyFrom( ClusterAutoscalingAutoprovisioningNodePoolDefaultsUpgradeSettings.to_proto( resource.upgrade_settings ) ) else: res.ClearField("upgrade_settings") if ClusterAutoscalingAutoprovisioningNodePoolDefaultsManagement.to_proto( resource.management ): res.management.CopyFrom( ClusterAutoscalingAutoprovisioningNodePoolDefaultsManagement.to_proto( resource.management ) ) else: res.ClearField("management") if Primitive.to_proto(resource.min_cpu_platform): res.min_cpu_platform = Primitive.to_proto(resource.min_cpu_platform) if Primitive.to_proto(resource.disk_size_gb): res.disk_size_gb = Primitive.to_proto(resource.disk_size_gb) if Primitive.to_proto(resource.disk_type): res.disk_type = Primitive.to_proto(resource.disk_type) if ClusterAutoscalingAutoprovisioningNodePoolDefaultsShieldedInstanceConfig.to_proto( resource.shielded_instance_config ): res.shielded_instance_config.CopyFrom( ClusterAutoscalingAutoprovisioningNodePoolDefaultsShieldedInstanceConfig.to_proto( resource.shielded_instance_config ) ) else: res.ClearField("shielded_instance_config") if Primitive.to_proto(resource.boot_disk_kms_key): res.boot_disk_kms_key = Primitive.to_proto(resource.boot_disk_kms_key) return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterAutoscalingAutoprovisioningNodePoolDefaults( oauth_scopes=Primitive.from_proto(resource.oauth_scopes), service_account=Primitive.from_proto(resource.service_account), upgrade_settings=ClusterAutoscalingAutoprovisioningNodePoolDefaultsUpgradeSettings.from_proto( resource.upgrade_settings ), management=ClusterAutoscalingAutoprovisioningNodePoolDefaultsManagement.from_proto( resource.management ), min_cpu_platform=Primitive.from_proto(resource.min_cpu_platform), disk_size_gb=Primitive.from_proto(resource.disk_size_gb), disk_type=Primitive.from_proto(resource.disk_type), shielded_instance_config=ClusterAutoscalingAutoprovisioningNodePoolDefaultsShieldedInstanceConfig.from_proto( resource.shielded_instance_config ), boot_disk_kms_key=Primitive.from_proto(resource.boot_disk_kms_key), ) class ClusterAutoscalingAutoprovisioningNodePoolDefaultsArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ ClusterAutoscalingAutoprovisioningNodePoolDefaults.to_proto(i) for i in resources ] @classmethod def from_proto(self, resources): return [ ClusterAutoscalingAutoprovisioningNodePoolDefaults.from_proto(i) for i in resources ] class ClusterAutoscalingAutoprovisioningNodePoolDefaultsUpgradeSettings(object): def __init__(self, max_surge: int = None, max_unavailable: int = None): self.max_surge = max_surge self.max_unavailable = max_unavailable @classmethod def to_proto(self, resource): if not resource: return None res = ( cluster_pb2.ContainerClusterAutoscalingAutoprovisioningNodePoolDefaultsUpgradeSettings() ) if Primitive.to_proto(resource.max_surge): res.max_surge = Primitive.to_proto(resource.max_surge) if Primitive.to_proto(resource.max_unavailable): res.max_unavailable = Primitive.to_proto(resource.max_unavailable) return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterAutoscalingAutoprovisioningNodePoolDefaultsUpgradeSettings( max_surge=Primitive.from_proto(resource.max_surge), max_unavailable=Primitive.from_proto(resource.max_unavailable), ) class ClusterAutoscalingAutoprovisioningNodePoolDefaultsUpgradeSettingsArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ ClusterAutoscalingAutoprovisioningNodePoolDefaultsUpgradeSettings.to_proto( i ) for i in resources ] @classmethod def from_proto(self, resources): return [ ClusterAutoscalingAutoprovisioningNodePoolDefaultsUpgradeSettings.from_proto( i ) for i in resources ] class ClusterAutoscalingAutoprovisioningNodePoolDefaultsManagement(object): def __init__( self, auto_upgrade: bool = None, auto_repair: bool = None, upgrade_options: dict = None, ): self.auto_upgrade = auto_upgrade self.auto_repair = auto_repair self.upgrade_options = upgrade_options @classmethod def to_proto(self, resource): if not resource: return None res = ( cluster_pb2.ContainerClusterAutoscalingAutoprovisioningNodePoolDefaultsManagement() ) if Primitive.to_proto(resource.auto_upgrade): res.auto_upgrade = Primitive.to_proto(resource.auto_upgrade) if Primitive.to_proto(resource.auto_repair): res.auto_repair = Primitive.to_proto(resource.auto_repair) if ClusterAutoscalingAutoprovisioningNodePoolDefaultsManagementUpgradeOptions.to_proto( resource.upgrade_options ): res.upgrade_options.CopyFrom( ClusterAutoscalingAutoprovisioningNodePoolDefaultsManagementUpgradeOptions.to_proto( resource.upgrade_options ) ) else: res.ClearField("upgrade_options") return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterAutoscalingAutoprovisioningNodePoolDefaultsManagement( auto_upgrade=Primitive.from_proto(resource.auto_upgrade), auto_repair=Primitive.from_proto(resource.auto_repair), upgrade_options=ClusterAutoscalingAutoprovisioningNodePoolDefaultsManagementUpgradeOptions.from_proto( resource.upgrade_options ), ) class ClusterAutoscalingAutoprovisioningNodePoolDefaultsManagementArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ ClusterAutoscalingAutoprovisioningNodePoolDefaultsManagement.to_proto(i) for i in resources ] @classmethod def from_proto(self, resources): return [ ClusterAutoscalingAutoprovisioningNodePoolDefaultsManagement.from_proto(i) for i in resources ] class ClusterAutoscalingAutoprovisioningNodePoolDefaultsManagementUpgradeOptions( object ): def __init__(self, auto_upgrade_start_time: str = None, description: str = None): self.auto_upgrade_start_time = auto_upgrade_start_time self.description = description @classmethod def to_proto(self, resource): if not resource: return None res = ( cluster_pb2.ContainerClusterAutoscalingAutoprovisioningNodePoolDefaultsManagementUpgradeOptions() ) if Primitive.to_proto(resource.auto_upgrade_start_time): res.auto_upgrade_start_time = Primitive.to_proto( resource.auto_upgrade_start_time ) if Primitive.to_proto(resource.description): res.description = Primitive.to_proto(resource.description) return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterAutoscalingAutoprovisioningNodePoolDefaultsManagementUpgradeOptions( auto_upgrade_start_time=Primitive.from_proto( resource.auto_upgrade_start_time ), description=Primitive.from_proto(resource.description), ) class ClusterAutoscalingAutoprovisioningNodePoolDefaultsManagementUpgradeOptionsArray( object ): @classmethod def to_proto(self, resources): if not resources: return resources return [ ClusterAutoscalingAutoprovisioningNodePoolDefaultsManagementUpgradeOptions.to_proto( i ) for i in resources ] @classmethod def from_proto(self, resources): return [ ClusterAutoscalingAutoprovisioningNodePoolDefaultsManagementUpgradeOptions.from_proto( i ) for i in resources ] class ClusterAutoscalingAutoprovisioningNodePoolDefaultsShieldedInstanceConfig(object): def __init__( self, enable_secure_boot: bool = None, enable_integrity_monitoring: bool = None ): self.enable_secure_boot = enable_secure_boot self.enable_integrity_monitoring = enable_integrity_monitoring @classmethod def to_proto(self, resource): if not resource: return None res = ( cluster_pb2.ContainerClusterAutoscalingAutoprovisioningNodePoolDefaultsShieldedInstanceConfig() ) if Primitive.to_proto(resource.enable_secure_boot): res.enable_secure_boot = Primitive.to_proto(resource.enable_secure_boot) if Primitive.to_proto(resource.enable_integrity_monitoring): res.enable_integrity_monitoring = Primitive.to_proto( resource.enable_integrity_monitoring ) return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterAutoscalingAutoprovisioningNodePoolDefaultsShieldedInstanceConfig( enable_secure_boot=Primitive.from_proto(resource.enable_secure_boot), enable_integrity_monitoring=Primitive.from_proto( resource.enable_integrity_monitoring ), ) class ClusterAutoscalingAutoprovisioningNodePoolDefaultsShieldedInstanceConfigArray( object ): @classmethod def to_proto(self, resources): if not resources: return resources return [ ClusterAutoscalingAutoprovisioningNodePoolDefaultsShieldedInstanceConfig.to_proto( i ) for i in resources ] @classmethod def from_proto(self, resources): return [ ClusterAutoscalingAutoprovisioningNodePoolDefaultsShieldedInstanceConfig.from_proto( i ) for i in resources ] class ClusterNetworkConfig(object): def __init__( self, network: str = None, subnetwork: str = None, enable_intra_node_visibility: bool = None, default_snat_status: dict = None, private_ipv6_google_access: str = None, ): self.network = network self.subnetwork = subnetwork self.enable_intra_node_visibility = enable_intra_node_visibility self.default_snat_status = default_snat_status self.private_ipv6_google_access = private_ipv6_google_access @classmethod def to_proto(self, resource): if not resource: return None res = cluster_pb2.ContainerClusterNetworkConfig() if Primitive.to_proto(resource.network): res.network = Primitive.to_proto(resource.network) if Primitive.to_proto(resource.subnetwork): res.subnetwork = Primitive.to_proto(resource.subnetwork) if Primitive.to_proto(resource.enable_intra_node_visibility): res.enable_intra_node_visibility = Primitive.to_proto( resource.enable_intra_node_visibility ) if ClusterNetworkConfigDefaultSnatStatus.to_proto(resource.default_snat_status): res.default_snat_status.CopyFrom( ClusterNetworkConfigDefaultSnatStatus.to_proto( resource.default_snat_status ) ) else: res.ClearField("default_snat_status") if ClusterNetworkConfigPrivateIPv6GoogleAccessEnum.to_proto( resource.private_ipv6_google_access ): res.private_ipv6_google_access = ClusterNetworkConfigPrivateIPv6GoogleAccessEnum.to_proto( resource.private_ipv6_google_access ) return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterNetworkConfig( network=Primitive.from_proto(resource.network), subnetwork=Primitive.from_proto(resource.subnetwork), enable_intra_node_visibility=Primitive.from_proto( resource.enable_intra_node_visibility ), default_snat_status=ClusterNetworkConfigDefaultSnatStatus.from_proto( resource.default_snat_status ), private_ipv6_google_access=ClusterNetworkConfigPrivateIPv6GoogleAccessEnum.from_proto( resource.private_ipv6_google_access ), ) class ClusterNetworkConfigArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ClusterNetworkConfig.to_proto(i) for i in resources] @classmethod def from_proto(self, resources): return [ClusterNetworkConfig.from_proto(i) for i in resources] class ClusterNetworkConfigDefaultSnatStatus(object): def __init__(self, disabled: bool = None): self.disabled = disabled @classmethod def to_proto(self, resource): if not resource: return None res = cluster_pb2.ContainerClusterNetworkConfigDefaultSnatStatus() if Primitive.to_proto(resource.disabled): res.disabled = Primitive.to_proto(resource.disabled) return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterNetworkConfigDefaultSnatStatus( disabled=Primitive.from_proto(resource.disabled), ) class ClusterNetworkConfigDefaultSnatStatusArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ClusterNetworkConfigDefaultSnatStatus.to_proto(i) for i in resources] @classmethod def from_proto(self, resources): return [ClusterNetworkConfigDefaultSnatStatus.from_proto(i) for i in resources] class ClusterMaintenancePolicy(object): def __init__(self, window: dict = None, resource_version: str = None): self.window = window self.resource_version = resource_version @classmethod def to_proto(self, resource): if not resource: return None res = cluster_pb2.ContainerClusterMaintenancePolicy() if ClusterMaintenancePolicyWindow.to_proto(resource.window): res.window.CopyFrom( ClusterMaintenancePolicyWindow.to_proto(resource.window) ) else: res.ClearField("window") if Primitive.to_proto(resource.resource_version): res.resource_version = Primitive.to_proto(resource.resource_version) return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterMaintenancePolicy( window=ClusterMaintenancePolicyWindow.from_proto(resource.window), resource_version=Primitive.from_proto(resource.resource_version), ) class ClusterMaintenancePolicyArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ClusterMaintenancePolicy.to_proto(i) for i in resources] @classmethod def from_proto(self, resources): return [ClusterMaintenancePolicy.from_proto(i) for i in resources] class ClusterMaintenancePolicyWindow(object): def __init__( self, daily_maintenance_window: dict = None, recurring_window: dict = None, maintenance_exclusions: dict = None, ): self.daily_maintenance_window = daily_maintenance_window self.recurring_window = recurring_window self.maintenance_exclusions = maintenance_exclusions @classmethod def to_proto(self, resource): if not resource: return None res = cluster_pb2.ContainerClusterMaintenancePolicyWindow() if ClusterMaintenancePolicyWindowDailyMaintenanceWindow.to_proto( resource.daily_maintenance_window ): res.daily_maintenance_window.CopyFrom( ClusterMaintenancePolicyWindowDailyMaintenanceWindow.to_proto( resource.daily_maintenance_window ) ) else: res.ClearField("daily_maintenance_window") if ClusterMaintenancePolicyWindowRecurringWindow.to_proto( resource.recurring_window ): res.recurring_window.CopyFrom( ClusterMaintenancePolicyWindowRecurringWindow.to_proto( resource.recurring_window ) ) else: res.ClearField("recurring_window") if Primitive.to_proto(resource.maintenance_exclusions): res.maintenance_exclusions = Primitive.to_proto( resource.maintenance_exclusions ) return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterMaintenancePolicyWindow( daily_maintenance_window=ClusterMaintenancePolicyWindowDailyMaintenanceWindow.from_proto( resource.daily_maintenance_window ), recurring_window=ClusterMaintenancePolicyWindowRecurringWindow.from_proto( resource.recurring_window ), maintenance_exclusions=Primitive.from_proto( resource.maintenance_exclusions ), ) class ClusterMaintenancePolicyWindowArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ClusterMaintenancePolicyWindow.to_proto(i) for i in resources] @classmethod def from_proto(self, resources): return [ClusterMaintenancePolicyWindow.from_proto(i) for i in resources] class ClusterMaintenancePolicyWindowDailyMaintenanceWindow(object): def __init__(self, start_time: str = None, duration: str = None): self.start_time = start_time self.duration = duration @classmethod def to_proto(self, resource): if not resource: return None res = ( cluster_pb2.ContainerClusterMaintenancePolicyWindowDailyMaintenanceWindow() ) if Primitive.to_proto(resource.start_time): res.start_time = Primitive.to_proto(resource.start_time) if Primitive.to_proto(resource.duration): res.duration = Primitive.to_proto(resource.duration) return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterMaintenancePolicyWindowDailyMaintenanceWindow( start_time=Primitive.from_proto(resource.start_time), duration=Primitive.from_proto(resource.duration), ) class ClusterMaintenancePolicyWindowDailyMaintenanceWindowArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ ClusterMaintenancePolicyWindowDailyMaintenanceWindow.to_proto(i) for i in resources ] @classmethod def from_proto(self, resources): return [ ClusterMaintenancePolicyWindowDailyMaintenanceWindow.from_proto(i) for i in resources ] class ClusterMaintenancePolicyWindowRecurringWindow(object): def __init__(self, window: dict = None, recurrence: str = None): self.window = window self.recurrence = recurrence @classmethod def to_proto(self, resource): if not resource: return None res = cluster_pb2.ContainerClusterMaintenancePolicyWindowRecurringWindow() if ClusterMaintenancePolicyWindowRecurringWindowWindow.to_proto( resource.window ): res.window.CopyFrom( ClusterMaintenancePolicyWindowRecurringWindowWindow.to_proto( resource.window ) ) else: res.ClearField("window") if Primitive.to_proto(resource.recurrence): res.recurrence = Primitive.to_proto(resource.recurrence) return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterMaintenancePolicyWindowRecurringWindow( window=ClusterMaintenancePolicyWindowRecurringWindowWindow.from_proto( resource.window ), recurrence=Primitive.from_proto(resource.recurrence), ) class ClusterMaintenancePolicyWindowRecurringWindowArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ ClusterMaintenancePolicyWindowRecurringWindow.to_proto(i) for i in resources ] @classmethod def from_proto(self, resources): return [ ClusterMaintenancePolicyWindowRecurringWindow.from_proto(i) for i in resources ] class ClusterMaintenancePolicyWindowRecurringWindowWindow(object): def __init__(self, start_time: str = None, end_time: str = None): self.start_time = start_time self.end_time = end_time @classmethod def to_proto(self, resource): if not resource: return None res = cluster_pb2.ContainerClusterMaintenancePolicyWindowRecurringWindowWindow() if Primitive.to_proto(resource.start_time): res.start_time = Primitive.to_proto(resource.start_time) if Primitive.to_proto(resource.end_time): res.end_time = Primitive.to_proto(resource.end_time) return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterMaintenancePolicyWindowRecurringWindowWindow( start_time=Primitive.from_proto(resource.start_time), end_time=Primitive.from_proto(resource.end_time), ) class ClusterMaintenancePolicyWindowRecurringWindowWindowArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ ClusterMaintenancePolicyWindowRecurringWindowWindow.to_proto(i) for i in resources ] @classmethod def from_proto(self, resources): return [ ClusterMaintenancePolicyWindowRecurringWindowWindow.from_proto(i) for i in resources ] class ClusterDefaultMaxPodsConstraint(object): def __init__(self, max_pods_per_node: str = None): self.max_pods_per_node = max_pods_per_node @classmethod def to_proto(self, resource): if not resource: return None res = cluster_pb2.ContainerClusterDefaultMaxPodsConstraint() if Primitive.to_proto(resource.max_pods_per_node): res.max_pods_per_node = Primitive.to_proto(resource.max_pods_per_node) return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterDefaultMaxPodsConstraint( max_pods_per_node=Primitive.from_proto(resource.max_pods_per_node), ) class ClusterDefaultMaxPodsConstraintArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ClusterDefaultMaxPodsConstraint.to_proto(i) for i in resources] @classmethod def from_proto(self, resources): return [ClusterDefaultMaxPodsConstraint.from_proto(i) for i in resources] class ClusterResourceUsageExportConfig(object): def __init__( self, bigquery_destination: dict = None, enable_network_egress_monitoring: bool = None, consumption_metering_config: dict = None, enable_network_egress_metering: bool = None, ): self.bigquery_destination = bigquery_destination self.enable_network_egress_monitoring = enable_network_egress_monitoring self.consumption_metering_config = consumption_metering_config self.enable_network_egress_metering = enable_network_egress_metering @classmethod def to_proto(self, resource): if not resource: return None res = cluster_pb2.ContainerClusterResourceUsageExportConfig() if ClusterResourceUsageExportConfigBigqueryDestination.to_proto( resource.bigquery_destination ): res.bigquery_destination.CopyFrom( ClusterResourceUsageExportConfigBigqueryDestination.to_proto( resource.bigquery_destination ) ) else: res.ClearField("bigquery_destination") if Primitive.to_proto(resource.enable_network_egress_monitoring): res.enable_network_egress_monitoring = Primitive.to_proto( resource.enable_network_egress_monitoring ) if ClusterResourceUsageExportConfigConsumptionMeteringConfig.to_proto( resource.consumption_metering_config ): res.consumption_metering_config.CopyFrom( ClusterResourceUsageExportConfigConsumptionMeteringConfig.to_proto( resource.consumption_metering_config ) ) else: res.ClearField("consumption_metering_config") if Primitive.to_proto(resource.enable_network_egress_metering): res.enable_network_egress_metering = Primitive.to_proto( resource.enable_network_egress_metering ) return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterResourceUsageExportConfig( bigquery_destination=ClusterResourceUsageExportConfigBigqueryDestination.from_proto( resource.bigquery_destination ), enable_network_egress_monitoring=Primitive.from_proto( resource.enable_network_egress_monitoring ), consumption_metering_config=ClusterResourceUsageExportConfigConsumptionMeteringConfig.from_proto( resource.consumption_metering_config ), enable_network_egress_metering=Primitive.from_proto( resource.enable_network_egress_metering ), ) class ClusterResourceUsageExportConfigArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ClusterResourceUsageExportConfig.to_proto(i) for i in resources] @classmethod def from_proto(self, resources): return [ClusterResourceUsageExportConfig.from_proto(i) for i in resources] class ClusterResourceUsageExportConfigBigqueryDestination(object): def __init__(self, dataset_id: str = None): self.dataset_id = dataset_id @classmethod def to_proto(self, resource): if not resource: return None res = cluster_pb2.ContainerClusterResourceUsageExportConfigBigqueryDestination() if Primitive.to_proto(resource.dataset_id): res.dataset_id = Primitive.to_proto(resource.dataset_id) return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterResourceUsageExportConfigBigqueryDestination( dataset_id=Primitive.from_proto(resource.dataset_id), ) class ClusterResourceUsageExportConfigBigqueryDestinationArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ ClusterResourceUsageExportConfigBigqueryDestination.to_proto(i) for i in resources ] @classmethod def from_proto(self, resources): return [ ClusterResourceUsageExportConfigBigqueryDestination.from_proto(i) for i in resources ] class ClusterResourceUsageExportConfigConsumptionMeteringConfig(object): def __init__(self, enabled: bool = None): self.enabled = enabled @classmethod def to_proto(self, resource): if not resource: return None res = ( cluster_pb2.ContainerClusterResourceUsageExportConfigConsumptionMeteringConfig() ) if Primitive.to_proto(resource.enabled): res.enabled = Primitive.to_proto(resource.enabled) return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterResourceUsageExportConfigConsumptionMeteringConfig( enabled=Primitive.from_proto(resource.enabled), ) class ClusterResourceUsageExportConfigConsumptionMeteringConfigArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ ClusterResourceUsageExportConfigConsumptionMeteringConfig.to_proto(i) for i in resources ] @classmethod def from_proto(self, resources): return [ ClusterResourceUsageExportConfigConsumptionMeteringConfig.from_proto(i) for i in resources ] class ClusterAuthenticatorGroupsConfig(object): def __init__(self, enabled: bool = None, security_group: str = None): self.enabled = enabled self.security_group = security_group @classmethod def to_proto(self, resource): if not resource: return None res = cluster_pb2.ContainerClusterAuthenticatorGroupsConfig() if Primitive.to_proto(resource.enabled): res.enabled = Primitive.to_proto(resource.enabled) if Primitive.to_proto(resource.security_group): res.security_group = Primitive.to_proto(resource.security_group) return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterAuthenticatorGroupsConfig( enabled=Primitive.from_proto(resource.enabled), security_group=Primitive.from_proto(resource.security_group), ) class ClusterAuthenticatorGroupsConfigArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ClusterAuthenticatorGroupsConfig.to_proto(i) for i in resources] @classmethod def from_proto(self, resources): return [ClusterAuthenticatorGroupsConfig.from_proto(i) for i in resources] class ClusterPrivateClusterConfig(object): def __init__( self, enable_private_nodes: bool = None, enable_private_endpoint: bool = None, master_ipv4_cidr_block: str = None, private_endpoint: str = None, public_endpoint: str = None, peering_name: str = None, master_global_access_config: dict = None, ): self.enable_private_nodes = enable_private_nodes self.enable_private_endpoint = enable_private_endpoint self.master_ipv4_cidr_block = master_ipv4_cidr_block self.private_endpoint = private_endpoint self.public_endpoint = public_endpoint self.peering_name = peering_name self.master_global_access_config = master_global_access_config @classmethod def to_proto(self, resource): if not resource: return None res = cluster_pb2.ContainerClusterPrivateClusterConfig() if Primitive.to_proto(resource.enable_private_nodes): res.enable_private_nodes = Primitive.to_proto(resource.enable_private_nodes) if Primitive.to_proto(resource.enable_private_endpoint): res.enable_private_endpoint = Primitive.to_proto( resource.enable_private_endpoint ) if Primitive.to_proto(resource.master_ipv4_cidr_block): res.master_ipv4_cidr_block = Primitive.to_proto( resource.master_ipv4_cidr_block ) if Primitive.to_proto(resource.private_endpoint): res.private_endpoint = Primitive.to_proto(resource.private_endpoint) if Primitive.to_proto(resource.public_endpoint): res.public_endpoint = Primitive.to_proto(resource.public_endpoint) if Primitive.to_proto(resource.peering_name): res.peering_name = Primitive.to_proto(resource.peering_name) if ClusterPrivateClusterConfigMasterGlobalAccessConfig.to_proto( resource.master_global_access_config ): res.master_global_access_config.CopyFrom( ClusterPrivateClusterConfigMasterGlobalAccessConfig.to_proto( resource.master_global_access_config ) ) else: res.ClearField("master_global_access_config") return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterPrivateClusterConfig( enable_private_nodes=Primitive.from_proto(resource.enable_private_nodes), enable_private_endpoint=Primitive.from_proto( resource.enable_private_endpoint ), master_ipv4_cidr_block=Primitive.from_proto( resource.master_ipv4_cidr_block ), private_endpoint=Primitive.from_proto(resource.private_endpoint), public_endpoint=Primitive.from_proto(resource.public_endpoint), peering_name=Primitive.from_proto(resource.peering_name), master_global_access_config=ClusterPrivateClusterConfigMasterGlobalAccessConfig.from_proto( resource.master_global_access_config ), ) class ClusterPrivateClusterConfigArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ClusterPrivateClusterConfig.to_proto(i) for i in resources] @classmethod def from_proto(self, resources): return [ClusterPrivateClusterConfig.from_proto(i) for i in resources] class ClusterPrivateClusterConfigMasterGlobalAccessConfig(object): def __init__(self, enabled: bool = None): self.enabled = enabled @classmethod def to_proto(self, resource): if not resource: return None res = cluster_pb2.ContainerClusterPrivateClusterConfigMasterGlobalAccessConfig() if Primitive.to_proto(resource.enabled): res.enabled = Primitive.to_proto(resource.enabled) return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterPrivateClusterConfigMasterGlobalAccessConfig( enabled=Primitive.from_proto(resource.enabled), ) class ClusterPrivateClusterConfigMasterGlobalAccessConfigArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ ClusterPrivateClusterConfigMasterGlobalAccessConfig.to_proto(i) for i in resources ] @classmethod def from_proto(self, resources): return [ ClusterPrivateClusterConfigMasterGlobalAccessConfig.from_proto(i) for i in resources ] class ClusterDatabaseEncryption(object): def __init__(self, state: str = None, key_name: str = None): self.state = state self.key_name = key_name @classmethod def to_proto(self, resource): if not resource: return None res = cluster_pb2.ContainerClusterDatabaseEncryption() if ClusterDatabaseEncryptionStateEnum.to_proto(resource.state): res.state = ClusterDatabaseEncryptionStateEnum.to_proto(resource.state) if Primitive.to_proto(resource.key_name): res.key_name = Primitive.to_proto(resource.key_name) return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterDatabaseEncryption( state=ClusterDatabaseEncryptionStateEnum.from_proto(resource.state), key_name=Primitive.from_proto(resource.key_name), ) class ClusterDatabaseEncryptionArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ClusterDatabaseEncryption.to_proto(i) for i in resources] @classmethod def from_proto(self, resources): return [ClusterDatabaseEncryption.from_proto(i) for i in resources] class ClusterVerticalPodAutoscaling(object): def __init__(self, enabled: bool = None): self.enabled = enabled @classmethod def to_proto(self, resource): if not resource: return None res = cluster_pb2.ContainerClusterVerticalPodAutoscaling() if Primitive.to_proto(resource.enabled): res.enabled = Primitive.to_proto(resource.enabled) return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterVerticalPodAutoscaling( enabled=Primitive.from_proto(resource.enabled), ) class ClusterVerticalPodAutoscalingArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ClusterVerticalPodAutoscaling.to_proto(i) for i in resources] @classmethod def from_proto(self, resources): return [ClusterVerticalPodAutoscaling.from_proto(i) for i in resources] class ClusterShieldedNodes(object): def __init__(self, enabled: bool = None): self.enabled = enabled @classmethod def to_proto(self, resource): if not resource: return None res = cluster_pb2.ContainerClusterShieldedNodes() if Primitive.to_proto(resource.enabled): res.enabled = Primitive.to_proto(resource.enabled) return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterShieldedNodes(enabled=Primitive.from_proto(resource.enabled),) class ClusterShieldedNodesArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ClusterShieldedNodes.to_proto(i) for i in resources] @classmethod def from_proto(self, resources): return [ClusterShieldedNodes.from_proto(i) for i in resources] class ClusterConditions(object): def __init__( self, code: str = None, message: str = None, canonical_code: str = None ): self.code = code self.message = message self.canonical_code = canonical_code @classmethod def to_proto(self, resource): if not resource: return None res = cluster_pb2.ContainerClusterConditions() if Primitive.to_proto(resource.code): res.code = Primitive.to_proto(resource.code) if Primitive.to_proto(resource.message): res.message = Primitive.to_proto(resource.message) if ClusterConditionsCanonicalCodeEnum.to_proto(resource.canonical_code): res.canonical_code = ClusterConditionsCanonicalCodeEnum.to_proto( resource.canonical_code ) return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterConditions( code=Primitive.from_proto(resource.code), message=Primitive.from_proto(resource.message), canonical_code=ClusterConditionsCanonicalCodeEnum.from_proto( resource.canonical_code ), ) class ClusterConditionsArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ClusterConditions.to_proto(i) for i in resources] @classmethod def from_proto(self, resources): return [ClusterConditions.from_proto(i) for i in resources] class ClusterAutopilot(object): def __init__(self, enabled: bool = None): self.enabled = enabled @classmethod def to_proto(self, resource): if not resource: return None res = cluster_pb2.ContainerClusterAutopilot() if Primitive.to_proto(resource.enabled): res.enabled = Primitive.to_proto(resource.enabled) return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterAutopilot(enabled=Primitive.from_proto(resource.enabled),) class ClusterAutopilotArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ClusterAutopilot.to_proto(i) for i in resources] @classmethod def from_proto(self, resources): return [ClusterAutopilot.from_proto(i) for i in resources] class ClusterNodeConfig(object): def __init__( self, machine_type: str = None, disk_size_gb: int = None, oauth_scopes: list = None, service_account: str = None, metadata: dict = None, image_type: str = None, labels: dict = None, local_ssd_count: int = None, tags: list = None, preemptible: bool = None, accelerators: list = None, disk_type: str = None, min_cpu_platform: str = None, workload_metadata_config: dict = None, taints: list = None, sandbox_config: dict = None, node_group: str = None, reservation_affinity: dict = None, shielded_instance_config: dict = None, linux_node_config: dict = None, kubelet_config: dict = None, boot_disk_kms_key: str = None, ): self.machine_type = machine_type self.disk_size_gb = disk_size_gb self.oauth_scopes = oauth_scopes self.service_account = service_account self.metadata = metadata self.image_type = image_type self.labels = labels self.local_ssd_count = local_ssd_count self.tags = tags self.preemptible = preemptible self.accelerators = accelerators self.disk_type = disk_type self.min_cpu_platform = min_cpu_platform self.workload_metadata_config = workload_metadata_config self.taints = taints self.sandbox_config = sandbox_config self.node_group = node_group self.reservation_affinity = reservation_affinity self.shielded_instance_config = shielded_instance_config self.linux_node_config = linux_node_config self.kubelet_config = kubelet_config self.boot_disk_kms_key = boot_disk_kms_key @classmethod def to_proto(self, resource): if not resource: return None res = cluster_pb2.ContainerClusterNodeConfig() if Primitive.to_proto(resource.machine_type): res.machine_type = Primitive.to_proto(resource.machine_type) if Primitive.to_proto(resource.disk_size_gb): res.disk_size_gb = Primitive.to_proto(resource.disk_size_gb) if Primitive.to_proto(resource.oauth_scopes): res.oauth_scopes.extend(Primitive.to_proto(resource.oauth_scopes)) if Primitive.to_proto(resource.service_account): res.service_account = Primitive.to_proto(resource.service_account) if Primitive.to_proto(resource.metadata): res.metadata = Primitive.to_proto(resource.metadata) if Primitive.to_proto(resource.image_type): res.image_type = Primitive.to_proto(resource.image_type) if Primitive.to_proto(resource.labels): res.labels = Primitive.to_proto(resource.labels) if Primitive.to_proto(resource.local_ssd_count): res.local_ssd_count = Primitive.to_proto(resource.local_ssd_count) if Primitive.to_proto(resource.tags): res.tags.extend(Primitive.to_proto(resource.tags)) if Primitive.to_proto(resource.preemptible): res.preemptible = Primitive.to_proto(resource.preemptible) if ClusterNodeConfigAcceleratorsArray.to_proto(resource.accelerators): res.accelerators.extend( ClusterNodeConfigAcceleratorsArray.to_proto(resource.accelerators) ) if Primitive.to_proto(resource.disk_type): res.disk_type = Primitive.to_proto(resource.disk_type) if Primitive.to_proto(resource.min_cpu_platform): res.min_cpu_platform = Primitive.to_proto(resource.min_cpu_platform) if ClusterNodeConfigWorkloadMetadataConfig.to_proto( resource.workload_metadata_config ): res.workload_metadata_config.CopyFrom( ClusterNodeConfigWorkloadMetadataConfig.to_proto( resource.workload_metadata_config ) ) else: res.ClearField("workload_metadata_config") if ClusterNodeConfigTaintsArray.to_proto(resource.taints): res.taints.extend(ClusterNodeConfigTaintsArray.to_proto(resource.taints)) if ClusterNodeConfigSandboxConfig.to_proto(resource.sandbox_config): res.sandbox_config.CopyFrom( ClusterNodeConfigSandboxConfig.to_proto(resource.sandbox_config) ) else: res.ClearField("sandbox_config") if Primitive.to_proto(resource.node_group): res.node_group = Primitive.to_proto(resource.node_group) if ClusterNodeConfigReservationAffinity.to_proto(resource.reservation_affinity): res.reservation_affinity.CopyFrom( ClusterNodeConfigReservationAffinity.to_proto( resource.reservation_affinity ) ) else: res.ClearField("reservation_affinity") if ClusterNodeConfigShieldedInstanceConfig.to_proto( resource.shielded_instance_config ): res.shielded_instance_config.CopyFrom( ClusterNodeConfigShieldedInstanceConfig.to_proto( resource.shielded_instance_config ) ) else: res.ClearField("shielded_instance_config") if ClusterNodeConfigLinuxNodeConfig.to_proto(resource.linux_node_config): res.linux_node_config.CopyFrom( ClusterNodeConfigLinuxNodeConfig.to_proto(resource.linux_node_config) ) else: res.ClearField("linux_node_config") if ClusterNodeConfigKubeletConfig.to_proto(resource.kubelet_config): res.kubelet_config.CopyFrom( ClusterNodeConfigKubeletConfig.to_proto(resource.kubelet_config) ) else: res.ClearField("kubelet_config") if Primitive.to_proto(resource.boot_disk_kms_key): res.boot_disk_kms_key = Primitive.to_proto(resource.boot_disk_kms_key) return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterNodeConfig( machine_type=Primitive.from_proto(resource.machine_type), disk_size_gb=Primitive.from_proto(resource.disk_size_gb), oauth_scopes=Primitive.from_proto(resource.oauth_scopes), service_account=Primitive.from_proto(resource.service_account), metadata=Primitive.from_proto(resource.metadata), image_type=Primitive.from_proto(resource.image_type), labels=Primitive.from_proto(resource.labels), local_ssd_count=Primitive.from_proto(resource.local_ssd_count), tags=Primitive.from_proto(resource.tags), preemptible=Primitive.from_proto(resource.preemptible), accelerators=ClusterNodeConfigAcceleratorsArray.from_proto( resource.accelerators ), disk_type=Primitive.from_proto(resource.disk_type), min_cpu_platform=Primitive.from_proto(resource.min_cpu_platform), workload_metadata_config=ClusterNodeConfigWorkloadMetadataConfig.from_proto( resource.workload_metadata_config ), taints=ClusterNodeConfigTaintsArray.from_proto(resource.taints), sandbox_config=ClusterNodeConfigSandboxConfig.from_proto( resource.sandbox_config ), node_group=Primitive.from_proto(resource.node_group), reservation_affinity=ClusterNodeConfigReservationAffinity.from_proto( resource.reservation_affinity ), shielded_instance_config=ClusterNodeConfigShieldedInstanceConfig.from_proto( resource.shielded_instance_config ), linux_node_config=ClusterNodeConfigLinuxNodeConfig.from_proto( resource.linux_node_config ), kubelet_config=ClusterNodeConfigKubeletConfig.from_proto( resource.kubelet_config ), boot_disk_kms_key=Primitive.from_proto(resource.boot_disk_kms_key), ) class ClusterNodeConfigArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ClusterNodeConfig.to_proto(i) for i in resources] @classmethod def from_proto(self, resources): return [ClusterNodeConfig.from_proto(i) for i in resources] class ClusterNodeConfigAccelerators(object): def __init__(self, accelerator_count: int = None, accelerator_type: str = None): self.accelerator_count = accelerator_count self.accelerator_type = accelerator_type @classmethod def to_proto(self, resource): if not resource: return None res = cluster_pb2.ContainerClusterNodeConfigAccelerators() if Primitive.to_proto(resource.accelerator_count): res.accelerator_count = Primitive.to_proto(resource.accelerator_count) if Primitive.to_proto(resource.accelerator_type): res.accelerator_type = Primitive.to_proto(resource.accelerator_type) return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterNodeConfigAccelerators( accelerator_count=Primitive.from_proto(resource.accelerator_count), accelerator_type=Primitive.from_proto(resource.accelerator_type), ) class ClusterNodeConfigAcceleratorsArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ClusterNodeConfigAccelerators.to_proto(i) for i in resources] @classmethod def from_proto(self, resources): return [ClusterNodeConfigAccelerators.from_proto(i) for i in resources] class ClusterNodeConfigWorkloadMetadataConfig(object): def __init__(self, mode: str = None): self.mode = mode @classmethod def to_proto(self, resource): if not resource: return None res = cluster_pb2.ContainerClusterNodeConfigWorkloadMetadataConfig() if ClusterNodeConfigWorkloadMetadataConfigModeEnum.to_proto(resource.mode): res.mode = ClusterNodeConfigWorkloadMetadataConfigModeEnum.to_proto( resource.mode ) return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterNodeConfigWorkloadMetadataConfig( mode=ClusterNodeConfigWorkloadMetadataConfigModeEnum.from_proto( resource.mode ), ) class ClusterNodeConfigWorkloadMetadataConfigArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ClusterNodeConfigWorkloadMetadataConfig.to_proto(i) for i in resources] @classmethod def from_proto(self, resources): return [ ClusterNodeConfigWorkloadMetadataConfig.from_proto(i) for i in resources ] class ClusterNodeConfigTaints(object): def __init__(self, key: str = None, value: str = None, effect: str = None): self.key = key self.value = value self.effect = effect @classmethod def to_proto(self, resource): if not resource: return None res = cluster_pb2.ContainerClusterNodeConfigTaints() if Primitive.to_proto(resource.key): res.key = Primitive.to_proto(resource.key) if Primitive.to_proto(resource.value): res.value = Primitive.to_proto(resource.value) if ClusterNodeConfigTaintsEffectEnum.to_proto(resource.effect): res.effect = ClusterNodeConfigTaintsEffectEnum.to_proto(resource.effect) return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterNodeConfigTaints( key=Primitive.from_proto(resource.key), value=Primitive.from_proto(resource.value), effect=ClusterNodeConfigTaintsEffectEnum.from_proto(resource.effect), ) class ClusterNodeConfigTaintsArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ClusterNodeConfigTaints.to_proto(i) for i in resources] @classmethod def from_proto(self, resources): return [ClusterNodeConfigTaints.from_proto(i) for i in resources] class ClusterNodeConfigSandboxConfig(object): def __init__(self, type: str = None): self.type = type @classmethod def to_proto(self, resource): if not resource: return None res = cluster_pb2.ContainerClusterNodeConfigSandboxConfig() if ClusterNodeConfigSandboxConfigTypeEnum.to_proto(resource.type): res.type = ClusterNodeConfigSandboxConfigTypeEnum.to_proto(resource.type) return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterNodeConfigSandboxConfig( type=ClusterNodeConfigSandboxConfigTypeEnum.from_proto(resource.type), ) class ClusterNodeConfigSandboxConfigArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ClusterNodeConfigSandboxConfig.to_proto(i) for i in resources] @classmethod def from_proto(self, resources): return [ClusterNodeConfigSandboxConfig.from_proto(i) for i in resources] class ClusterNodeConfigReservationAffinity(object): def __init__( self, consume_reservation_type: str = None, key: str = None, values: list = None ): self.consume_reservation_type = consume_reservation_type self.key = key self.values = values @classmethod def to_proto(self, resource): if not resource: return None res = cluster_pb2.ContainerClusterNodeConfigReservationAffinity() if ClusterNodeConfigReservationAffinityConsumeReservationTypeEnum.to_proto( resource.consume_reservation_type ): res.consume_reservation_type = ClusterNodeConfigReservationAffinityConsumeReservationTypeEnum.to_proto( resource.consume_reservation_type ) if Primitive.to_proto(resource.key): res.key = Primitive.to_proto(resource.key) if Primitive.to_proto(resource.values): res.values.extend(Primitive.to_proto(resource.values)) return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterNodeConfigReservationAffinity( consume_reservation_type=ClusterNodeConfigReservationAffinityConsumeReservationTypeEnum.from_proto( resource.consume_reservation_type ), key=Primitive.from_proto(resource.key), values=Primitive.from_proto(resource.values), ) class ClusterNodeConfigReservationAffinityArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ClusterNodeConfigReservationAffinity.to_proto(i) for i in resources] @classmethod def from_proto(self, resources): return [ClusterNodeConfigReservationAffinity.from_proto(i) for i in resources] class ClusterNodeConfigShieldedInstanceConfig(object): def __init__( self, enable_secure_boot: bool = None, enable_integrity_monitoring: bool = None ): self.enable_secure_boot = enable_secure_boot self.enable_integrity_monitoring = enable_integrity_monitoring @classmethod def to_proto(self, resource): if not resource: return None res = cluster_pb2.ContainerClusterNodeConfigShieldedInstanceConfig() if Primitive.to_proto(resource.enable_secure_boot): res.enable_secure_boot = Primitive.to_proto(resource.enable_secure_boot) if Primitive.to_proto(resource.enable_integrity_monitoring): res.enable_integrity_monitoring = Primitive.to_proto( resource.enable_integrity_monitoring ) return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterNodeConfigShieldedInstanceConfig( enable_secure_boot=Primitive.from_proto(resource.enable_secure_boot), enable_integrity_monitoring=Primitive.from_proto( resource.enable_integrity_monitoring ), ) class ClusterNodeConfigShieldedInstanceConfigArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ClusterNodeConfigShieldedInstanceConfig.to_proto(i) for i in resources] @classmethod def from_proto(self, resources): return [ ClusterNodeConfigShieldedInstanceConfig.from_proto(i) for i in resources ] class ClusterNodeConfigLinuxNodeConfig(object): def __init__(self, sysctls: dict = None): self.sysctls = sysctls @classmethod def to_proto(self, resource): if not resource: return None res = cluster_pb2.ContainerClusterNodeConfigLinuxNodeConfig() if Primitive.to_proto(resource.sysctls): res.sysctls = Primitive.to_proto(resource.sysctls) return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterNodeConfigLinuxNodeConfig( sysctls=Primitive.from_proto(resource.sysctls), ) class ClusterNodeConfigLinuxNodeConfigArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ClusterNodeConfigLinuxNodeConfig.to_proto(i) for i in resources] @classmethod def from_proto(self, resources): return [ClusterNodeConfigLinuxNodeConfig.from_proto(i) for i in resources] class ClusterNodeConfigKubeletConfig(object): def __init__( self, cpu_manager_policy: str = None, cpu_cfs_quota: bool = None, cpu_cfs_quota_period: str = None, ): self.cpu_manager_policy = cpu_manager_policy self.cpu_cfs_quota = cpu_cfs_quota self.cpu_cfs_quota_period = cpu_cfs_quota_period @classmethod def to_proto(self, resource): if not resource: return None res = cluster_pb2.ContainerClusterNodeConfigKubeletConfig() if Primitive.to_proto(resource.cpu_manager_policy): res.cpu_manager_policy = Primitive.to_proto(resource.cpu_manager_policy) if Primitive.to_proto(resource.cpu_cfs_quota): res.cpu_cfs_quota = Primitive.to_proto(resource.cpu_cfs_quota) if Primitive.to_proto(resource.cpu_cfs_quota_period): res.cpu_cfs_quota_period = Primitive.to_proto(resource.cpu_cfs_quota_period) return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterNodeConfigKubeletConfig( cpu_manager_policy=Primitive.from_proto(resource.cpu_manager_policy), cpu_cfs_quota=Primitive.from_proto(resource.cpu_cfs_quota), cpu_cfs_quota_period=Primitive.from_proto(resource.cpu_cfs_quota_period), ) class ClusterNodeConfigKubeletConfigArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ClusterNodeConfigKubeletConfig.to_proto(i) for i in resources] @classmethod def from_proto(self, resources): return [ClusterNodeConfigKubeletConfig.from_proto(i) for i in resources] class ClusterReleaseChannel(object): def __init__(self, channel: str = None): self.channel = channel @classmethod def to_proto(self, resource): if not resource: return None res = cluster_pb2.ContainerClusterReleaseChannel() if ClusterReleaseChannelChannelEnum.to_proto(resource.channel): res.channel = ClusterReleaseChannelChannelEnum.to_proto(resource.channel) return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterReleaseChannel( channel=ClusterReleaseChannelChannelEnum.from_proto(resource.channel), ) class ClusterReleaseChannelArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ClusterReleaseChannel.to_proto(i) for i in resources] @classmethod def from_proto(self, resources): return [ClusterReleaseChannel.from_proto(i) for i in resources] class ClusterWorkloadIdentityConfig(object): def __init__(self, workload_pool: str = None): self.workload_pool = workload_pool @classmethod def to_proto(self, resource): if not resource: return None res = cluster_pb2.ContainerClusterWorkloadIdentityConfig() if Primitive.to_proto(resource.workload_pool): res.workload_pool = Primitive.to_proto(resource.workload_pool) return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterWorkloadIdentityConfig( workload_pool=Primitive.from_proto(resource.workload_pool), ) class ClusterWorkloadIdentityConfigArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ClusterWorkloadIdentityConfig.to_proto(i) for i in resources] @classmethod def from_proto(self, resources): return [ClusterWorkloadIdentityConfig.from_proto(i) for i in resources] class ClusterNotificationConfig(object): def __init__(self, pubsub: dict = None): self.pubsub = pubsub @classmethod def to_proto(self, resource): if not resource: return None res = cluster_pb2.ContainerClusterNotificationConfig() if ClusterNotificationConfigPubsub.to_proto(resource.pubsub): res.pubsub.CopyFrom( ClusterNotificationConfigPubsub.to_proto(resource.pubsub) ) else: res.ClearField("pubsub") return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterNotificationConfig( pubsub=ClusterNotificationConfigPubsub.from_proto(resource.pubsub), ) class ClusterNotificationConfigArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ClusterNotificationConfig.to_proto(i) for i in resources] @classmethod def from_proto(self, resources): return [ClusterNotificationConfig.from_proto(i) for i in resources] class ClusterNotificationConfigPubsub(object): def __init__(self, enabled: bool = None, topic: str = None): self.enabled = enabled self.topic = topic @classmethod def to_proto(self, resource): if not resource: return None res = cluster_pb2.ContainerClusterNotificationConfigPubsub() if Primitive.to_proto(resource.enabled): res.enabled = Primitive.to_proto(resource.enabled) if Primitive.to_proto(resource.topic): res.topic = Primitive.to_proto(resource.topic) return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterNotificationConfigPubsub( enabled=Primitive.from_proto(resource.enabled), topic=Primitive.from_proto(resource.topic), ) class ClusterNotificationConfigPubsubArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ClusterNotificationConfigPubsub.to_proto(i) for i in resources] @classmethod def from_proto(self, resources): return [ClusterNotificationConfigPubsub.from_proto(i) for i in resources] class ClusterConfidentialNodes(object): def __init__(self, enabled: bool = None): self.enabled = enabled @classmethod def to_proto(self, resource): if not resource: return None res = cluster_pb2.ContainerClusterConfidentialNodes() if Primitive.to_proto(resource.enabled): res.enabled = Primitive.to_proto(resource.enabled) return res @classmethod def from_proto(self, resource): if not resource: return None return ClusterConfidentialNodes(enabled=Primitive.from_proto(resource.enabled),) class ClusterConfidentialNodesArray(object): @classmethod def to_proto(self, resources): if not resources: return resources return [ClusterConfidentialNodes.to_proto(i) for i in resources] @classmethod def from_proto(self, resources): return [ClusterConfidentialNodes.from_proto(i) for i in resources] class ClusterAddonsConfigCloudRunConfigLoadBalancerTypeEnum(object): @classmethod def to_proto(self, resource): if not resource: return resource return cluster_pb2.ContainerClusterAddonsConfigCloudRunConfigLoadBalancerTypeEnum.Value( "ContainerClusterAddonsConfigCloudRunConfigLoadBalancerTypeEnum%s" % resource ) @classmethod def from_proto(self, resource): if not resource: return resource return cluster_pb2.ContainerClusterAddonsConfigCloudRunConfigLoadBalancerTypeEnum.Name( resource )[ len("ContainerClusterAddonsConfigCloudRunConfigLoadBalancerTypeEnum") : ] class ClusterNodePoolsConfigWorkloadMetadataConfigModeEnum(object): @classmethod def to_proto(self, resource): if not resource: return resource return cluster_pb2.ContainerClusterNodePoolsConfigWorkloadMetadataConfigModeEnum.Value( "ContainerClusterNodePoolsConfigWorkloadMetadataConfigModeEnum%s" % resource ) @classmethod def from_proto(self, resource): if not resource: return resource return cluster_pb2.ContainerClusterNodePoolsConfigWorkloadMetadataConfigModeEnum.Name( resource )[ len("ContainerClusterNodePoolsConfigWorkloadMetadataConfigModeEnum") : ] class ClusterNodePoolsConfigTaintsEffectEnum(object): @classmethod def to_proto(self, resource): if not resource: return resource return cluster_pb2.ContainerClusterNodePoolsConfigTaintsEffectEnum.Value( "ContainerClusterNodePoolsConfigTaintsEffectEnum%s" % resource ) @classmethod def from_proto(self, resource): if not resource: return resource return cluster_pb2.ContainerClusterNodePoolsConfigTaintsEffectEnum.Name( resource )[len("ContainerClusterNodePoolsConfigTaintsEffectEnum") :] class ClusterNodePoolsConfigSandboxConfigTypeEnum(object): @classmethod def to_proto(self, resource): if not resource: return resource return cluster_pb2.ContainerClusterNodePoolsConfigSandboxConfigTypeEnum.Value( "ContainerClusterNodePoolsConfigSandboxConfigTypeEnum%s" % resource ) @classmethod def from_proto(self, resource): if not resource: return resource return cluster_pb2.ContainerClusterNodePoolsConfigSandboxConfigTypeEnum.Name( resource )[len("ContainerClusterNodePoolsConfigSandboxConfigTypeEnum") :] class ClusterNodePoolsConfigReservationAffinityConsumeReservationTypeEnum(object): @classmethod def to_proto(self, resource): if not resource: return resource return cluster_pb2.ContainerClusterNodePoolsConfigReservationAffinityConsumeReservationTypeEnum.Value( "ContainerClusterNodePoolsConfigReservationAffinityConsumeReservationTypeEnum%s" % resource ) @classmethod def from_proto(self, resource): if not resource: return resource return cluster_pb2.ContainerClusterNodePoolsConfigReservationAffinityConsumeReservationTypeEnum.Name( resource )[ len( "ContainerClusterNodePoolsConfigReservationAffinityConsumeReservationTypeEnum" ) : ] class ClusterNodePoolsStatusEnum(object): @classmethod def to_proto(self, resource): if not resource: return resource return cluster_pb2.ContainerClusterNodePoolsStatusEnum.Value( "ContainerClusterNodePoolsStatusEnum%s" % resource ) @classmethod def from_proto(self, resource): if not resource: return resource return cluster_pb2.ContainerClusterNodePoolsStatusEnum.Name(resource)[ len("ContainerClusterNodePoolsStatusEnum") : ] class ClusterNodePoolsConditionsCodeEnum(object): @classmethod def to_proto(self, resource): if not resource: return resource return cluster_pb2.ContainerClusterNodePoolsConditionsCodeEnum.Value( "ContainerClusterNodePoolsConditionsCodeEnum%s" % resource ) @classmethod def from_proto(self, resource): if not resource: return resource return cluster_pb2.ContainerClusterNodePoolsConditionsCodeEnum.Name(resource)[ len("ContainerClusterNodePoolsConditionsCodeEnum") : ] class ClusterNodePoolsConditionsCanonicalCodeEnum(object): @classmethod def to_proto(self, resource): if not resource: return resource return cluster_pb2.ContainerClusterNodePoolsConditionsCanonicalCodeEnum.Value( "ContainerClusterNodePoolsConditionsCanonicalCodeEnum%s" % resource ) @classmethod def from_proto(self, resource): if not resource: return resource return cluster_pb2.ContainerClusterNodePoolsConditionsCanonicalCodeEnum.Name( resource )[len("ContainerClusterNodePoolsConditionsCanonicalCodeEnum") :] class ClusterNetworkPolicyProviderEnum(object): @classmethod def to_proto(self, resource): if not resource: return resource return cluster_pb2.ContainerClusterNetworkPolicyProviderEnum.Value( "ContainerClusterNetworkPolicyProviderEnum%s" % resource ) @classmethod def from_proto(self, resource): if not resource: return resource return cluster_pb2.ContainerClusterNetworkPolicyProviderEnum.Name(resource)[ len("ContainerClusterNetworkPolicyProviderEnum") : ] class ClusterNetworkConfigPrivateIPv6GoogleAccessEnum(object): @classmethod def to_proto(self, resource): if not resource: return resource return cluster_pb2.ContainerClusterNetworkConfigPrivateIPv6GoogleAccessEnum.Value( "ContainerClusterNetworkConfigPrivateIPv6GoogleAccessEnum%s" % resource ) @classmethod def from_proto(self, resource): if not resource: return resource return cluster_pb2.ContainerClusterNetworkConfigPrivateIPv6GoogleAccessEnum.Name( resource )[ len("ContainerClusterNetworkConfigPrivateIPv6GoogleAccessEnum") : ] class ClusterDatabaseEncryptionStateEnum(object): @classmethod def to_proto(self, resource): if not resource: return resource return cluster_pb2.ContainerClusterDatabaseEncryptionStateEnum.Value( "ContainerClusterDatabaseEncryptionStateEnum%s" % resource ) @classmethod def from_proto(self, resource): if not resource: return resource return cluster_pb2.ContainerClusterDatabaseEncryptionStateEnum.Name(resource)[ len("ContainerClusterDatabaseEncryptionStateEnum") : ] class ClusterConditionsCanonicalCodeEnum(object): @classmethod def to_proto(self, resource): if not resource: return resource return cluster_pb2.ContainerClusterConditionsCanonicalCodeEnum.Value( "ContainerClusterConditionsCanonicalCodeEnum%s" % resource ) @classmethod def from_proto(self, resource): if not resource: return resource return cluster_pb2.ContainerClusterConditionsCanonicalCodeEnum.Name(resource)[ len("ContainerClusterConditionsCanonicalCodeEnum") : ] class ClusterNodeConfigWorkloadMetadataConfigModeEnum(object): @classmethod def to_proto(self, resource): if not resource: return resource return cluster_pb2.ContainerClusterNodeConfigWorkloadMetadataConfigModeEnum.Value( "ContainerClusterNodeConfigWorkloadMetadataConfigModeEnum%s" % resource ) @classmethod def from_proto(self, resource): if not resource: return resource return cluster_pb2.ContainerClusterNodeConfigWorkloadMetadataConfigModeEnum.Name( resource )[ len("ContainerClusterNodeConfigWorkloadMetadataConfigModeEnum") : ] class ClusterNodeConfigTaintsEffectEnum(object): @classmethod def to_proto(self, resource): if not resource: return resource return cluster_pb2.ContainerClusterNodeConfigTaintsEffectEnum.Value( "ContainerClusterNodeConfigTaintsEffectEnum%s" % resource ) @classmethod def from_proto(self, resource): if not resource: return resource return cluster_pb2.ContainerClusterNodeConfigTaintsEffectEnum.Name(resource)[ len("ContainerClusterNodeConfigTaintsEffectEnum") : ] class ClusterNodeConfigSandboxConfigTypeEnum(object): @classmethod def to_proto(self, resource): if not resource: return resource return cluster_pb2.ContainerClusterNodeConfigSandboxConfigTypeEnum.Value( "ContainerClusterNodeConfigSandboxConfigTypeEnum%s" % resource ) @classmethod def from_proto(self, resource): if not resource: return resource return cluster_pb2.ContainerClusterNodeConfigSandboxConfigTypeEnum.Name( resource )[len("ContainerClusterNodeConfigSandboxConfigTypeEnum") :] class ClusterNodeConfigReservationAffinityConsumeReservationTypeEnum(object): @classmethod def to_proto(self, resource): if not resource: return resource return cluster_pb2.ContainerClusterNodeConfigReservationAffinityConsumeReservationTypeEnum.Value( "ContainerClusterNodeConfigReservationAffinityConsumeReservationTypeEnum%s" % resource ) @classmethod def from_proto(self, resource): if not resource: return resource return cluster_pb2.ContainerClusterNodeConfigReservationAffinityConsumeReservationTypeEnum.Name( resource )[ len( "ContainerClusterNodeConfigReservationAffinityConsumeReservationTypeEnum" ) : ] class ClusterReleaseChannelChannelEnum(object): @classmethod def to_proto(self, resource): if not resource: return resource return cluster_pb2.ContainerClusterReleaseChannelChannelEnum.Value( "ContainerClusterReleaseChannelChannelEnum%s" % resource ) @classmethod def from_proto(self, resource): if not resource: return resource return cluster_pb2.ContainerClusterReleaseChannelChannelEnum.Name(resource)[ len("ContainerClusterReleaseChannelChannelEnum") : ] class Primitive(object): @classmethod def to_proto(self, s): if not s: return "" return s @classmethod def from_proto(self, s): return s

python/services/container/cluster.py (4,470 lines of code) (raw):