openshift-python-wrapper 10.0.88__tar.gz → 10.0.92__tar.gz

openshift_python_wrapper-10.0.92/PKG-INFO

@@ -0,0 +1,120 @@
+Metadata-Version: 2.1
+Name: openshift-python-wrapper
+Version: 10.0.92
+Summary: Wrapper around https://github.com/kubernetes-client/python
+Home-page: https://github.com/RedHatQE/openshift-python-wrapper
+License: Apache-2.0
+Keywords: Openshift,Kubevirt,Openshift Virtualization
+Author: Meni Yakove
+Author-email: myakove@gmail.com
+Requires-Python: >=3.8,<4.0
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: click (>=8.1.7,<9.0.0)
+Requires-Dist: cloup (>=3.0.5,<4.0.0)
+Requires-Dist: colorlog (>=6.7.0,<7.0.0)
+Requires-Dist: jinja2 (>=3.1.2,<4.0.0)
+Requires-Dist: kubernetes (==30.*)
+Requires-Dist: packaging (>=23.1,<24.0)
+Requires-Dist: pyhelper-utils (>=0.0.42,<0.0.43)
+Requires-Dist: pytest (>=8.0.0,<9.0.0)
+Requires-Dist: python-benedict (>=0.33.0,<0.34.0)
+Requires-Dist: python-simple-logger (>=1.0.6)
+Requires-Dist: rich (>=13.7.1,<14.0.0)
+Requires-Dist: ruff (>=0.6.0,<0.7.0)
+Requires-Dist: timeout-sampler (>=0.0.17)
+Requires-Dist: xmltodict (>=0.13.0,<0.14.0)
+Project-URL: Bug Tracker, https://github.com/RedHatQE/openshift-python-wrapper/issues
+Project-URL: Documentation, https://openshift-python-wrapper.readthedocs.io/en/latest/
+Project-URL: Download, https://pypi.org/project/openshift-python-wrapper/
+Description-Content-Type: text/markdown
+
+# openshift-python-wrapper (`wrapper`)
+Pypi: [openshift-python-wrapper](https://pypi.org/project/openshift-python-wrapper)  
+A python wrapper for [kubernetes-python-client](https://github.com/kubernetes-client/python) with support for [RedHat Container Virtualization](https://www.openshift.com/learn/topics/virtualization)  
+Docs: [openshift-python-wrapper docs](https://openshift-python-wrapper.readthedocs.io/en/latest/)
+
+The wrapper offers a simple and intuitive interface for interacting with the API.  
+It standardizes how to work with cluster resources and offers unified resource CRUD (Create, Read, Update, and Delete) flows.  
+The wrapper also provides additional capabilities, such as resource-specific functionality that otherwise needs to be implemented by users.  
+The wrapper makes code easier to read and maintain over time.
+
+One example of simplified usage is interacting with a container.  
+Running a command inside a container requires using Kubernetes stream, handling errors, and more.  
+The wrapper handles it all and provides simple and intuitive functionality.
+
+![Alt Text](examples/pod_example.gif)
+
+Both developers or testers can use the wrapper.  The code is modular and easy to maintain.  
+Instead of writing custom code for every API, you can use the wrapper that provides a consistent interface for interacting with APIs.  
+It saves time, avoids code duplications, and reduces the chance of errors.
+
+Using Python capabilities, context managers can provide out-of-the-box resource creation and deletion,  
+and inheritance can be used to extend functionality for specific use cases.  
+Pytest fixtures can utilize the code for setup and teardown, leaving no leftovers.  
+Resources can even be saved for debugging.  
+Resource manifests and logs can be easily collected.
+
+## Installation
+From source:
+```bash
+git clone https://github.com/RedHatQE/openshift-python-wrapper.git
+cd openshift-python-wrapper
+python setup.py install --user
+```
+From pypi:
+```bash
+pip install openshift-python-wrapper --user
+```
+
+## Release new version
+### requirements:
+* Export GitHub token
+```bash
+export GITHUB_TOKEN=<your_github_token>
+```
+* [release-it](https://github.com/release-it/release-it)
+```bash
+sudo npm install --global release-it
+npm install --save-dev @release-it/bumper
+```
+### usage:
+* Create a release, run from the relevant branch.  
+To create a 4.11 release, run:
+```bash
+git checkout v4.11
+git pull
+release-it # Follow the instructions
+```
+
+## docs
+Hosted on readthedocs.io [openshift-python-wrapper](https://openshift-python-wrapper.readthedocs.io/en/latest/)
+
+## PR dependency
+For PR dependency we use [dpulls](https://www.dpulls.com/)  
+To make PR depends on other PR add `depends on #<PR NUMBER>` in the PR description.
+
+## Logging configuration
+To change log level export OPENSHIFT_PYTHON_WRAPPER_LOG_LEVEL:  
+
+```bash
+export OPENSHIFT_PYTHON_WRAPPER_LOG_LEVEL=<LOG_LEVEL> # can be: "DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"
+```
+
+## Code check
+We use pre-commit for code check.
+```bash
+pre-commit install
+```
+
+Some code examples locate at [examples](examples) directory
+
+## Contribute to the project
+To contribute new additions or changes to the project, please refer to the [contribution guide](CONTRIBUTING.md) first.
+

openshift_python_wrapper-10.0.92/class_generator/manifests/class_generator_template.j2

@@ -0,0 +1,95 @@
+{% set all_types_for_class_args = [] %}
+{% set all_names_types_for_docstring = [] %}
+{% set all_required_args = [] %}
+{% for arg in fields + spec %}
+  {% set _ = all_types_for_class_args.append(arg["type-for-class-arg"]|safe) %}
+  {% set _ = all_names_types_for_docstring.append(arg["name-for-class-arg"] + " (" + arg["type-for-docstring"] + "): " +  arg["description"]|indent(10)|safe ) %}
+  {% set _ = all_required_args.append(arg["name-for-class-arg"]) if arg["required"] == True %}
+{% endfor %}
+# Generated using https://github.com/RedHatQE/openshift-python-wrapper/blob/main/scripts/resource/README.md
+
+from typing import Any, Dict, List, Optional
+from ocp_resources.resource import {{ base_class }}, MissingRequiredArgumentError
+
+
+class {{ kind }}({{ base_class }}):
+    """
+    {{ description }}
+    """
+
+    {% if group %}
+    api_group: str = {{ base_class }}.ApiGroup.{{ group.upper() }}
+    {% else %}
+    api_version: str = {{ base_class }}.ApiVersion.{{ version.upper() }}
+    {% endif %}
+
+    def __init__(
+        self,
+        {% if all_types_for_class_args %}
+        {{ all_types_for_class_args|join(",\n        ") }},
+        {% endif %}
+        **kwargs: Any,
+    ) -> None:
+        {% if all_types_for_class_args %}
+        """
+        Args:
+            {% for value in all_names_types_for_docstring %}
+            {{ value }}
+            {% endfor %}
+        """
+        {% endif %}
+        super().__init__(**kwargs)
+
+        {% for arg in fields + spec %}
+        self.{{ arg["name-for-class-arg"] }} = {{ arg["name-for-class-arg"] }}
+        {% endfor %}
+
+    {% if fields or spec %}
+    def to_dict(self) -> None:
+
+        super().to_dict()
+
+        if not self.kind_dict and not self.yaml_file:
+          {% if all_required_args %}
+            if not all([{% for arg in all_required_args %}self.{{ arg }},{% endfor %}]):
+                raise MissingRequiredArgumentError(argument="{{ all_required_args|join(', ') }}")
+          {% endif %}
+
+          {% if spec %}
+            self.res["spec"] = {}
+            _spec = self.res["spec"]
+          {% endif %}
+
+          {# Add required args under `self.res` #}
+          {% for arg in fields %}
+          {% if arg["required"] == True %}
+            self.res["{{ arg["property-name"] }}"] = self.{{ arg["name-for-class-arg"] }}
+          {% endif %}
+          {% endfor %}
+
+          {# Add required args under `_spec` #}
+          {% for arg in spec %}
+          {% if arg["required"] == True %}
+            _spec["{{ arg["property-name"] }}"] = self.{{ arg["name-for-class-arg"] }}
+          {% endif %}
+          {% endfor %}
+
+          {# Add optional args under `self.res` #}
+          {% for arg in fields %}
+          {% if arg["required"] == False %}
+            if self.{{ arg["name-for-class-arg"] }}{% if arg["type-for-docstring"] == "bool" %} is not None{% endif %}:
+                self.res["{{ arg["property-name"] }}"] = self.{{ arg["name-for-class-arg"] }}
+
+          {% endif %}
+          {% endfor %}
+
+          {# Add optional args under `_spec` #}
+          {% for arg in spec %}
+          {% if arg["required"] == False %}
+            if self.{{ arg["name-for-class-arg"] }}{% if arg["type-for-docstring"] == "bool" %} is not None{% endif %}:
+                _spec["{{ arg["property-name"] }}"] = self.{{ arg["name-for-class-arg"] }}
+
+          {% endif %}
+          {% endfor %}
+    {% endif %}
+    # End of generated code

openshift_python_wrapper-10.0.92/class_generator/tests/manifests/APIServer/api_server.py

@@ -0,0 +1,94 @@
+# Generated using https://github.com/RedHatQE/openshift-python-wrapper/blob/main/scripts/resource/README.md
+
+from typing import Any, Dict, List, Optional
+from ocp_resources.resource import Resource
+
+
+class APIServer(Resource):
+    """
+       APIServer holds configuration (like serving certificates, client CA and CORS domains) shared by all API servers in the system, among them especially kube-apiserver and openshift-apiserver. The canonical name of an instance is 'cluster'.
+    Compatibility level 1: Stable within a major release for a minimum of 12 months or 3 minor releases (whichever is longer).
+    """
+
+    api_group: str = Resource.ApiGroup.CONFIG_OPENSHIFT_IO
+
+    def __init__(
+        self,
+        additional_cors_allowed_origins: Optional[List[Any]] = None,
+        audit: Optional[Dict[str, Any]] = None,
+        client_ca: Optional[Dict[str, Any]] = None,
+        encryption: Optional[Dict[str, Any]] = None,
+        serving_certs: Optional[Dict[str, Any]] = None,
+        tls_security_profile: Optional[Dict[str, Any]] = None,
+        **kwargs: Any,
+    ) -> None:
+        """
+        Args:
+            additional_cors_allowed_origins (List[Any]): additionalCORSAllowedOrigins lists additional, user-defined regular
+              expressions describing hosts for which the API server allows
+              access using the CORS headers. This may be needed to access the
+              API and the integrated OAuth server from JavaScript applications.
+              The values are regular expressions that correspond to the Golang
+              regular expression language.
+
+            audit (Dict[str, Any]): audit specifies the settings for audit configuration to be applied to
+              all OpenShift-provided API servers in the cluster.
+
+            client_ca (Dict[str, Any]): clientCA references a ConfigMap containing a certificate bundle for
+              the signers that will be recognized for incoming client
+              certificates in addition to the operator managed signers. If this
+              is empty, then only operator managed signers are valid. You
+              usually only have to set this if you have your own PKI you wish to
+              honor client certificates from. The ConfigMap must exist in the
+              openshift-config namespace and contain the following required
+              fields: - ConfigMap.Data["ca-bundle.crt"] - CA bundle.
+
+            encryption (Dict[str, Any]): encryption allows the configuration of encryption of resources at the
+              datastore layer.
+
+            serving_certs (Dict[str, Any]): servingCert is the TLS cert info for serving secure traffic. If not
+              specified, operator managed certificates will be used for serving
+              secure traffic.
+
+            tls_security_profile (Dict[str, Any]): tlsSecurityProfile specifies settings for TLS connections for
+              externally exposed servers.   If unset, a default (which may
+              change between releases) is chosen. Note that only Old,
+              Intermediate and Custom profiles are currently supported, and the
+              maximum available minTLSVersion is VersionTLS12.
+
+        """
+        super().__init__(**kwargs)
+
+        self.additional_cors_allowed_origins = additional_cors_allowed_origins
+        self.audit = audit
+        self.client_ca = client_ca
+        self.encryption = encryption
+        self.serving_certs = serving_certs
+        self.tls_security_profile = tls_security_profile
+
+    def to_dict(self) -> None:
+        super().to_dict()
+
+        if not self.kind_dict and not self.yaml_file:
+            self.res["spec"] = {}
+            _spec = self.res["spec"]
+
+            if self.additional_cors_allowed_origins:
+                _spec["additionalCORSAllowedOrigins"] = self.additional_cors_allowed_origins
+
+            if self.audit:
+                _spec["audit"] = self.audit
+
+            if self.client_ca:
+                _spec["clientCA"] = self.client_ca
+
+            if self.encryption:
+                _spec["encryption"] = self.encryption
+
+            if self.serving_certs:
+                _spec["servingCerts"] = self.serving_certs
+
+            if self.tls_security_profile:
+                _spec["tlsSecurityProfile"] = self.tls_security_profile
+
+    # End of generated code

openshift_python_wrapper-10.0.92/class_generator/tests/manifests/ConfigMap/config_map.py

@@ -0,0 +1,61 @@
+# Generated using https://github.com/RedHatQE/openshift-python-wrapper/blob/main/scripts/resource/README.md
+
+from typing import Any, Dict, Optional
+from ocp_resources.resource import NamespacedResource
+
+
+class ConfigMap(NamespacedResource):
+    """
+    ConfigMap holds configuration data for pods to consume.
+    """
+
+    api_version: str = NamespacedResource.ApiVersion.V1
+
+    def __init__(
+        self,
+        binary_data: Optional[Dict[str, Any]] = None,
+        data: Optional[Dict[str, Any]] = None,
+        immutable: Optional[bool] = None,
+        **kwargs: Any,
+    ) -> None:
+        """
+        Args:
+            binary_data (Dict[str, Any]): BinaryData contains the binary data. Each key must consist of
+              alphanumeric characters, '-', '_' or '.'. BinaryData can contain
+              byte sequences that are not in the UTF-8 range. The keys stored in
+              BinaryData must not overlap with the ones in the Data field, this
+              is enforced during validation process. Using this field will
+              require 1.10+ apiserver and kubelet.
+
+            data (Dict[str, Any]): Data contains the configuration data. Each key must consist of
+              alphanumeric characters, '-', '_' or '.'. Values with non-UTF-8
+              byte sequences must use the BinaryData field. The keys stored in
+              Data must not overlap with the keys in the BinaryData field, this
+              is enforced during validation process.
+
+            immutable (bool): Immutable, if set to true, ensures that data stored in the ConfigMap
+              cannot be updated (only object metadata can be modified). If not
+              set to true, the field can be modified at any time. Defaulted to
+              nil.
+
+        """
+        super().__init__(**kwargs)
+
+        self.binary_data = binary_data
+        self.data = data
+        self.immutable = immutable
+
+    def to_dict(self) -> None:
+        super().to_dict()
+
+        if not self.kind_dict and not self.yaml_file:
+            if self.binary_data:
+                self.res["binaryData"] = self.binary_data
+
+            if self.data:
+                self.res["data"] = self.data
+
+            if self.immutable is not None:
+                self.res["immutable"] = self.immutable
+
+    # End of generated code

openshift_python_wrapper-10.0.92/class_generator/tests/manifests/DNS/dns_config_openshift_io.py

@@ -0,0 +1,73 @@
+# Generated using https://github.com/RedHatQE/openshift-python-wrapper/blob/main/scripts/resource/README.md
+
+from typing import Any, Dict, Optional
+from ocp_resources.resource import Resource
+
+
+class DNS(Resource):
+    """
+       DNS holds cluster-wide information about DNS. The canonical name is `cluster`
+    Compatibility level 1: Stable within a major release for a minimum of 12 months or 3 minor releases (whichever is longer).
+    """
+
+    api_group: str = Resource.ApiGroup.CONFIG_OPENSHIFT_IO
+
+    def __init__(
+        self,
+        base_domain: Optional[str] = "",
+        platform: Optional[Dict[str, Any]] = None,
+        private_zone: Optional[Dict[str, Any]] = None,
+        public_zone: Optional[Dict[str, Any]] = None,
+        **kwargs: Any,
+    ) -> None:
+        """
+        Args:
+            base_domain (str): baseDomain is the base domain of the cluster. All managed DNS records
+              will be sub-domains of this base.   For example, given the base
+              domain `openshift.example.com`, an API server DNS record may be
+              created for `cluster-api.openshift.example.com`.   Once set, this
+              field cannot be changed.
+
+            platform (Dict[str, Any]): platform holds configuration specific to the underlying infrastructure
+              provider for DNS. When omitted, this means the user has no opinion
+              and the platform is left to choose reasonable defaults. These
+              defaults are subject to change over time.
+
+            private_zone (Dict[str, Any]): privateZone is the location where all the DNS records that are only
+              available internally to the cluster exist.   If this field is nil,
+              no private records should be created.   Once set, this field
+              cannot be changed.
+
+            public_zone (Dict[str, Any]): publicZone is the location where all the DNS records that are publicly
+              accessible to the internet exist.   If this field is nil, no
+              public records should be created.   Once set, this field cannot be
+              changed.
+
+        """
+        super().__init__(**kwargs)
+
+        self.base_domain = base_domain
+        self.platform = platform
+        self.private_zone = private_zone
+        self.public_zone = public_zone
+
+    def to_dict(self) -> None:
+        super().to_dict()
+
+        if not self.kind_dict and not self.yaml_file:
+            self.res["spec"] = {}
+            _spec = self.res["spec"]
+
+            if self.base_domain:
+                _spec["baseDomain"] = self.base_domain
+
+            if self.platform:
+                _spec["platform"] = self.platform
+
+            if self.private_zone:
+                _spec["privateZone"] = self.private_zone
+
+            if self.public_zone:
+                _spec["publicZone"] = self.public_zone
+
+    # End of generated code

openshift_python_wrapper-10.0.92/class_generator/tests/manifests/DNS/dns_operator_openshift_io.py

@@ -0,0 +1,122 @@
+# Generated using https://github.com/RedHatQE/openshift-python-wrapper/blob/main/scripts/resource/README.md
+
+from typing import Any, Dict, List, Optional
+from ocp_resources.resource import Resource
+
+
+class DNS(Resource):
+    """
+       DNS manages the CoreDNS component to provide a name resolution service for pods and services in the cluster.
+    This supports the DNS-based service discovery specification: https://github.com/kubernetes/dns/blob/master/docs/specification.md
+    More details: https://kubernetes.io/docs/tasks/administer-cluster/coredns
+    Compatibility level 1: Stable within a major release for a minimum of 12 months or 3 minor releases (whichever is longer).
+    """
+
+    api_group: str = Resource.ApiGroup.OPERATOR_OPENSHIFT_IO
+
+    def __init__(
+        self,
+        cache: Optional[Dict[str, Any]] = None,
+        log_level: Optional[str] = "",
+        management_state: Optional[str] = "",
+        node_placement: Optional[Dict[str, Any]] = None,
+        operator_log_level: Optional[str] = "",
+        servers: Optional[List[Any]] = None,
+        upstream_resolvers: Optional[Dict[str, Any]] = None,
+        **kwargs: Any,
+    ) -> None:
+        """
+        Args:
+            cache (Dict[str, Any]): cache describes the caching configuration that applies to all server
+              blocks listed in the Corefile. This field allows a cluster admin
+              to optionally configure: * positiveTTL which is a duration for
+              which positive responses should be cached. * negativeTTL which is
+              a duration for which negative responses should be cached. If this
+              is not configured, OpenShift will configure positive and negative
+              caching with a default value that is subject to change. At the
+              time of writing, the default positiveTTL is 900 seconds and the
+              default negativeTTL is 30 seconds or as noted in the respective
+              Corefile for your version of OpenShift.
+
+            log_level (str): logLevel describes the desired logging verbosity for CoreDNS. Any one
+              of the following values may be specified: * Normal logs errors
+              from upstream resolvers. * Debug logs errors, NXDOMAIN responses,
+              and NODATA responses. * Trace logs errors and all responses.
+              Setting logLevel: Trace will produce extremely verbose logs. Valid
+              values are: "Normal", "Debug", "Trace". Defaults to "Normal".
+
+            management_state (str): managementState indicates whether the DNS operator should manage
+              cluster DNS
+
+            node_placement (Dict[str, Any]): nodePlacement provides explicit control over the scheduling of DNS
+              pods.   Generally, it is useful to run a DNS pod on every node so
+              that DNS queries are always handled by a local DNS pod instead of
+              going over the network to a DNS pod on another node.  However,
+              security policies may require restricting the placement of DNS
+              pods to specific nodes. For example, if a security policy
+              prohibits pods on arbitrary nodes from communicating with the API,
+              a node selector can be specified to restrict DNS pods to nodes
+              that are permitted to communicate with the API.  Conversely, if
+              running DNS pods on nodes with a particular taint is desired, a
+              toleration can be specified for that taint.   If unset, defaults
+              are used. See nodePlacement for more details.
+
+            operator_log_level (str): operatorLogLevel controls the logging level of the DNS Operator. Valid
+              values are: "Normal", "Debug", "Trace". Defaults to "Normal".
+              setting operatorLogLevel: Trace will produce extremely verbose
+              logs.
+
+            servers (List[Any]): servers is a list of DNS resolvers that provide name query delegation
+              for one or more subdomains outside the scope of the cluster
+              domain. If servers consists of more than one Server, longest
+              suffix match will be used to determine the Server.   For example,
+              if there are two Servers, one for "foo.com" and another for
+              "a.foo.com", and the name query is for "www.a.foo.com", it will be
+              routed to the Server with Zone "a.foo.com".   If this field is
+              nil, no servers are created.
+
+            upstream_resolvers (Dict[str, Any]): upstreamResolvers defines a schema for configuring CoreDNS to proxy
+              DNS messages to upstream resolvers for the case of the default
+              (".") server   If this field is not specified, the upstream used
+              will default to /etc/resolv.conf, with policy "sequential"
+
+        """
+        super().__init__(**kwargs)
+
+        self.cache = cache
+        self.log_level = log_level
+        self.management_state = management_state
+        self.node_placement = node_placement
+        self.operator_log_level = operator_log_level
+        self.servers = servers
+        self.upstream_resolvers = upstream_resolvers
+
+    def to_dict(self) -> None:
+        super().to_dict()
+
+        if not self.kind_dict and not self.yaml_file:
+            self.res["spec"] = {}
+            _spec = self.res["spec"]
+
+            if self.cache:
+                _spec["cache"] = self.cache
+
+            if self.log_level:
+                _spec["logLevel"] = self.log_level
+
+            if self.management_state:
+                _spec["managementState"] = self.management_state
+
+            if self.node_placement:
+                _spec["nodePlacement"] = self.node_placement
+
+            if self.operator_log_level:
+                _spec["operatorLogLevel"] = self.operator_log_level
+
+            if self.servers:
+                _spec["servers"] = self.servers
+
+            if self.upstream_resolvers:
+                _spec["upstreamResolvers"] = self.upstream_resolvers
+
+    # End of generated code

openshift_python_wrapper-10.0.92/class_generator/tests/manifests/Deployment/deployment.py

@@ -0,0 +1,106 @@
+# Generated using https://github.com/RedHatQE/openshift-python-wrapper/blob/main/scripts/resource/README.md
+
+from typing import Any, Dict, Optional
+from ocp_resources.resource import NamespacedResource, MissingRequiredArgumentError
+
+
+class Deployment(NamespacedResource):
+    """
+    Deployment enables declarative updates for Pods and ReplicaSets.
+    """
+
+    api_group: str = NamespacedResource.ApiGroup.APPS
+
+    def __init__(
+        self,
+        min_ready_seconds: Optional[int] = None,
+        paused: Optional[bool] = None,
+        progress_deadline_seconds: Optional[int] = None,
+        replicas: Optional[int] = None,
+        revision_history_limit: Optional[int] = None,
+        selector: Optional[Dict[str, Any]] = None,
+        strategy: Optional[Dict[str, Any]] = None,
+        template: Optional[Dict[str, Any]] = None,
+        **kwargs: Any,
+    ) -> None:
+        """
+        Args:
+            min_ready_seconds (int): Minimum number of seconds for which a newly created pod should be
+              ready without any of its container crashing, for it to be
+              considered available. Defaults to 0 (pod will be considered
+              available as soon as it is ready)
+
+            paused (bool): Indicates that the deployment is paused.
+
+            progress_deadline_seconds (int): The maximum time in seconds for a deployment to make progress before
+              it is considered to be failed. The deployment controller will
+              continue to process failed deployments and a condition with a
+              ProgressDeadlineExceeded reason will be surfaced in the deployment
+              status. Note that progress will not be estimated during the time a
+              deployment is paused. Defaults to 600s.
+
+            replicas (int): Number of desired pods. This is a pointer to distinguish between
+              explicit zero and not specified. Defaults to 1.
+
+            revision_history_limit (int): The number of old ReplicaSets to retain to allow rollback. This is a
+              pointer to distinguish between explicit zero and not specified.
+              Defaults to 10.
+
+            selector (Dict[str, Any]): A label selector is a label query over a set of resources. The result
+              of matchLabels and matchExpressions are ANDed. An empty label
+              selector matches all objects. A null label selector matches no
+              objects.
+
+            strategy (Dict[str, Any]): DeploymentStrategy describes how to replace existing pods with new
+              ones.
+
+            template (Dict[str, Any]): PodTemplateSpec describes the data a pod should have when created from
+              a template
+
+        """
+        super().__init__(**kwargs)
+
+        self.min_ready_seconds = min_ready_seconds
+        self.paused = paused
+        self.progress_deadline_seconds = progress_deadline_seconds
+        self.replicas = replicas
+        self.revision_history_limit = revision_history_limit
+        self.selector = selector
+        self.strategy = strategy
+        self.template = template
+
+    def to_dict(self) -> None:
+        super().to_dict()
+
+        if not self.kind_dict and not self.yaml_file:
+            if not all([
+                self.selector,
+                self.template,
+            ]):
+                raise MissingRequiredArgumentError(argument="selector, template")
+
+            self.res["spec"] = {}
+            _spec = self.res["spec"]
+
+            _spec["selector"] = self.selector
+            _spec["template"] = self.template
+
+            if self.min_ready_seconds:
+                _spec["minReadySeconds"] = self.min_ready_seconds
+
+            if self.paused is not None:
+                _spec["paused"] = self.paused
+
+            if self.progress_deadline_seconds:
+                _spec["progressDeadlineSeconds"] = self.progress_deadline_seconds
+
+            if self.replicas:
+                _spec["replicas"] = self.replicas
+
+            if self.revision_history_limit:
+                _spec["revisionHistoryLimit"] = self.revision_history_limit
+
+            if self.strategy:
+                _spec["strategy"] = self.strategy
+
+    # End of generated code