Your advanced code editor is loading.

Please wait a moment.

#editor-loading { display: none; }

””” Kubernetes

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

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

””“

import pprint import re # noqa: F401

import six

from kubernetes.client.configuration import Configuration

class V1ResourceQuotaSpec(object): “”“NOTE: This class is auto generated by OpenAPI Generator. Ref: https://openapi-generator.tech

Do not edit the class manually.
          """
          
          """
          Attributes:
          openapi_types (dict): The key is attribute name
          and the value is attribute type.
          attribute_map (dict): The key is attribute name
          and the value is json key in definition.
          """
          openapi_types = {
          'hard': 'dict(str, str)',
          'scope_selector': 'V1ScopeSelector',
          'scopes': 'list[str]'
          }
          attribute_map = {
          'hard': 'hard',
          'scope_selector': 'scopeSelector',
          'scopes': 'scopes'
          }
          def init(self, hard=None, scope_selector=None, scopes=None, local_vars_configuration=None):  # noqa: E501
          """V1ResourceQuotaSpec - a model defined in OpenAPI"""  # noqa: E501
          if local_vars_configuration is None:
          local_vars_configuration = Configuration()
          self.local_vars_configuration = local_vars_configuration
          self._hard = None
          self._scope_selector = None
          self._scopes = None
          self.discriminator = None
          if hard is not None:
          self.hard = hard
          if scope_selector is not None:
          self.scope_selector = scope_selector
          if scopes is not None:
          self.scopes = scopes
          @property
          def hard(self):
          """Gets the hard of this V1ResourceQuotaSpec.  # noqa: E501
          hard is the set of desired hard limits for each named resource. More info: https://kubernetes.io/docs/concepts/policy/resource-quotas/  # noqa: E501
          :return: The hard of this V1ResourceQuotaSpec.  # noqa: E501
          :rtype: dict(str, str)
          """
          return self._hard
          @hard.setter
          def hard(self, hard):
          """Sets the hard of this V1ResourceQuotaSpec.
          hard is the set of desired hard limits for each named resource. More info: https://kubernetes.io/docs/concepts/policy/resource-quotas/  # noqa: E501
          :param hard: The hard of this V1ResourceQuotaSpec.  # noqa: E501
          :type: dict(str, str)
          """
          self._hard = hard
          @property
          def scope_selector(self):
          """Gets the scope_selector of this V1ResourceQuotaSpec.  # noqa: E501
          :return: The scope_selector of this V1ResourceQuotaSpec.  # noqa: E501
          :rtype: V1ScopeSelector
          """
          return self._scope_selector
          @scope_selector.setter
          def scope_selector(self, scope_selector):
          """Sets the scope_selector of this V1ResourceQuotaSpec.
          :param scope_selector: The scope_selector of this V1ResourceQuotaSpec.  # noqa: E501
          :type: V1ScopeSelector
          """
          self._scope_selector = scope_selector
          @property
          def scopes(self):
          """Gets the scopes of this V1ResourceQuotaSpec.  # noqa: E501
          A collection of filters that must match each object tracked by a quota. If not specified, the quota matches all objects.  # noqa: E501
          :return: The scopes of this V1ResourceQuotaSpec.  # noqa: E501
          :rtype: list[str]
          """
          return self._scopes
          @scopes.setter
          def scopes(self, scopes):
          """Sets the scopes of this V1ResourceQuotaSpec.
          A collection of filters that must match each object tracked by a quota. If not specified, the quota matches all objects.  # noqa: E501
          :param scopes: The scopes of this V1ResourceQuotaSpec.  # noqa: E501
          :type: list[str]
          """
          self._scopes = scopes
          def to_dict(self):
          """Returns the model properties as a dict"""
          result = {}
          for attr, _ in six.iteritems(self.openapi_types):
          value = getattr(self, attr)
          if isinstance(value, list):
          result[attr] = list(map(
          lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
          value
          ))
          elif hasattr(value, "to_dict"):
          result[attr] = value.to_dict()
          elif isinstance(value, dict):
          result[attr] = dict(map(
          lambda item: (item[0], item[1].to_dict())
          if hasattr(item[1], "to_dict") else item,
          value.items()
          ))
          else:
          result[attr] = value
          return result
          def to_str(self):
          """Returns the string representation of the model"""
          return pprint.pformat(self.to_dict())
          def repr(self):
          """For print and pprint”””
          return self.to_str()
          def eq(self, other):
          “”“Returns true if both objects are equal”“”
          if not isinstance(other, V1ResourceQuotaSpec):
          return False
          return self.to_dict() == other.to_dict()
          def ne(self, other):
          “”“Returns true if both objects are not equal”“”
          if not isinstance(other, V1ResourceQuotaSpec):
          return True
          return self.to_dict() != other.to_dict()

Explanation

This code defines a Python class V1ResourceQuotaSpec that represents a Kubernetes resource quota specification. It’s part of the Kubernetes client library for Python.

Here’s a breakdown of the code:

Class Definition:

V1ResourceQuotaSpec: This class defines the structure of a resource quota specification. It’s used to specify limits on various resources within a Kubernetes namespace.

Attributes:

hard: A dictionary that defines the hard limits for each resource. The keys are the resource names (e.g., “cpu”, “memory”), and the values are the limit values (e.g., “2”, “5Gi”).
scope_selector: A V1ScopeSelector object that defines a scope selector for the resource quota. This allows you to target specific kinds of resources.
scopes: A list of strings representing resource scopes that are subject to this quota. Each string is a resource type (e.g., “pods”, “services”, “replicationcontrollers”).

Methods:

__init__(self, hard=None, scope_selector=None, scopes=None, local_vars_configuration=None): The constructor initializes the object with optional values for hard, scope_selector, and scopes.
hard(): A getter method to retrieve the hard attribute.
hard(self, hard): A setter method to update the hard attribute.
scope_selector(): A getter method to retrieve the scope_selector attribute.
scope_selector(self, scope_selector): A setter method to update the scope_selector attribute.
scopes(): A getter method to retrieve the scopes attribute.
scopes(self, scopes): A setter method to update the scopes attribute.
to_dict(): A method to convert the object into a dictionary representation.
to_str(): A method to convert the object into a string representation.
__repr__(): A method that returns a string representation of the object for use with print and pprint.
__eq__(self, other): A method to compare the object with another object for equality.
__ne__(self, other): A method to compare the object with another object for inequality.

Usage:

This class is used by the Kubernetes client library to represent and work with resource quota specifications. For example, you could create an instance of V1ResourceQuotaSpec and set the hard limits for various resources:

from kubernetes.client.models.v1_resource_quota_spec import V1ResourceQuotaSpec

quota_spec = V1ResourceQuotaSpec(
hard={"cpu": "2", "memory": "5Gi"},
scopes=["pods", "services"]
)

This quota_spec object would then be used when creating or updating a resource quota object in Kubernetes.

Key Points:

This class provides a way to define limits on resource consumption within a Kubernetes namespace.
The hard attribute allows specifying maximum limits for various resource types, ensuring resource availability and preventing excessive resource usage.
The scope_selector and scopes attributes allow for targeting specific types of resources to be subject to the quota.
The Kubernetes client library uses this class to work with resource quota specifications, allowing for automated creation, update, and management of resource quotas.

Your advanced code editor is loading.

Please wait a moment.

Explanation

Graph

Symbols

We couldn't identify any entrypoints. If you believe this to be incorrect then please contact support.