openshift-python-wrapper 10.0.76__tar.gz → 10.0.77__tar.gz

{openshift_python_wrapper-10.0.76 → openshift_python_wrapper-10.0.77}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: openshift-python-wrapper
-Version: 10.0.76
+Version: 10.0.77
 Summary: Wrapper around https://github.com/kubernetes-client/python
 Home-page: https://github.com/RedHatQE/openshift-python-wrapper
 License: Apache-2.0

{openshift_python_wrapper-10.0.76 → openshift_python_wrapper-10.0.77}/class_generator/class_generator.py

@@ -37,7 +37,7 @@ RESOURCES_MAPPING_FILE: str = os.path.join(SCHEMA_DIR, "__resources-mappings.jso
 
 
 def _is_kind_and_namespaced(client: str, _key: str, _data: Dict[str, Any]) -> Dict[str, Any]:
-    x_kubernetes_group_version_kind = _data["x-kubernetes-group-version-kind"][0]
+    x_kubernetes_group_version_kind = extract_group_kind_version(_kind_schema=_data)
     _kind = x_kubernetes_group_version_kind["kind"]
     _group = x_kubernetes_group_version_kind.get("group")
     _version = x_kubernetes_group_version_kind.get("version")
@@ -366,34 +366,39 @@ def generate_resource_file_from_dict(
 
 
 def types_generator(key_dict: Dict[str, Any]) -> Dict[str, str]:
-    type_for_docstring: str = "Dict[str, Any]"
+    type_for_docstring: str = "Any"
     type_from_dict_for_init: str = ""
+    # A resource field may be defined with `x-kubernetes-preserve-unknown-fields`. In this case, `type` is not provided.
+    resource_type = key_dict.get("type")
 
     # All fields must be set with Optional since resource can have yaml_file to cover all args.
-    if key_dict["type"] == "array":
+    if resource_type == "array":
         type_for_docstring = "List[Any]"
 
-    elif key_dict["type"] == "string":
+    elif resource_type == "string":
         type_for_docstring = "str"
         type_from_dict_for_init = f'Optional[{type_for_docstring}] = ""'
 
-    elif key_dict["type"] == "boolean":
+    elif resource_type == "boolean":
         type_for_docstring = "bool"
 
-    elif key_dict["type"] == "integer":
+    elif resource_type == "integer":
         type_for_docstring = "int"
 
+    elif resource_type == "object":
+        type_for_docstring = "Dict[str, Any]"
+
     if not type_from_dict_for_init:
         type_from_dict_for_init = f"Optional[{type_for_docstring}] = None"
 
     return {"type-for-init": type_from_dict_for_init, "type-for-doc": type_for_docstring}
 
 
-def get_property_schema(property: Dict[str, Any]) -> Dict[str, Any]:
-    if _ref := property.get("$ref"):
+def get_property_schema(property_: Dict[str, Any]) -> Dict[str, Any]:
+    if _ref := property_.get("$ref"):
         with open(f"{SCHEMA_DIR}/{_ref.rsplit('.')[-1].lower()}.json") as fd:
             return json.load(fd)
-    return property
+    return property_
 
 
 def format_description(description: str) -> str:
@@ -419,14 +424,16 @@ def prepare_property_dict(
         if key in keys_to_ignore:
             continue
 
-        val_schema = get_property_schema(property=val)
+        val_schema = get_property_schema(property_=val)
         type_dict = types_generator(key_dict=val_schema)
         python_name = convert_camel_case_to_snake_case(string_=key)
         resource_dict[dict_key].append({
             "name-for-class-arg": python_name,
             "property-name": key,
             "required": key in required,
-            "description": format_description(description=val_schema["description"]),
+            "description": format_description(
+                description=val_schema.get("description", "No field description from API; please add description")
+            ),
             "type-for-docstring": type_dict["type-for-doc"],
             "type-for-class-arg": f"{python_name}: {type_dict['type-for-init']}",
         })
@@ -452,10 +459,11 @@ def parse_explain(
 
         schema_properties: Dict[str, Any] = _kind_schema["properties"]
         fields_required = _kind_schema.get("required", [])
-        resource_dict.update(_kind_schema["x-kubernetes-group-version-kind"][0])
+
+        resource_dict.update(extract_group_kind_version(_kind_schema=_kind_schema))
 
         if spec_schema := schema_properties.get("spec", {}):
-            spec_schema = get_property_schema(property=spec_schema)
+            spec_schema = get_property_schema(property_=spec_schema)
             spec_required = spec_schema.get("required", [])
             resource_dict = prepare_property_dict(
                 schema=spec_schema.get("properties", {}),
@@ -508,6 +516,17 @@ def parse_explain(
     return _resources
 
 
+def extract_group_kind_version(_kind_schema: Dict[str, Any]) -> Dict[str, str]:
+    group_kind_versions: List[Dict[str, str]] = _kind_schema["x-kubernetes-group-version-kind"]
+    group_kind_version = group_kind_versions[0]
+
+    for group_kind_version in group_kind_versions:
+        if group_kind_version.get("group"):
+            break
+
+    return group_kind_version
+
+
 def class_generator(
     kind: str,
     overwrite: bool = False,

openshift_python_wrapper-10.0.77/class_generator/tests/manifests/Image/image_config_openshift_io.py

@@ -0,0 +1,75 @@
+# 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 Image(Resource):
+    """
+       Image governs policies related to imagestream imports and runtime configuration for external registries. It allows cluster admins to configure which registries OpenShift is allowed to import images from, extra CA trust bundles for external registries, and policies to block or allow registry hostnames. When exposing OpenShift's image registry to the public, this also lets cluster admins specify the external hostname.
+    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_trusted_ca: Optional[Dict[str, Any]] = None,
+        allowed_registries_for_import: Optional[List[Any]] = None,
+        external_registry_hostnames: Optional[List[Any]] = None,
+        registry_sources: Optional[Dict[str, Any]] = None,
+        **kwargs: Any,
+    ) -> None:
+        """
+        Args:
+            additional_trusted_ca(Dict[str, Any]): additionalTrustedCA is a reference to a ConfigMap containing
+              additional CAs that should be trusted during imagestream import,
+              pod image pull, build image pull, and imageregistry pullthrough.
+              The namespace for this config map is openshift-config.
+
+            allowed_registries_for_import(List[Any]): allowedRegistriesForImport limits the container image registries that
+              normal users may import images from. Set this list to the
+              registries that you trust to contain valid Docker images and that
+              you want applications to be able to import from. Users with
+              permission to create Images or ImageStreamMappings via the API are
+              not affected by this policy - typically only administrators or
+              system integrations will have those permissions.
+
+            external_registry_hostnames(List[Any]): externalRegistryHostnames provides the hostnames for the default
+              external image registry. The external hostname should be set only
+              when the image registry is exposed externally. The first value is
+              used in 'publicDockerImageRepository' field in ImageStreams. The
+              value must be in "hostname[:port]" format.
+
+            registry_sources(Dict[str, Any]): registrySources contains configuration that determines how the
+              container runtime should treat individual registries when
+              accessing images for builds+pods. (e.g. whether or not to allow
+              insecure access).  It does not contain configuration for the
+              internal cluster registry.
+
+        """
+        super().__init__(**kwargs)
+
+        self.additional_trusted_ca = additional_trusted_ca
+        self.allowed_registries_for_import = allowed_registries_for_import
+        self.external_registry_hostnames = external_registry_hostnames
+        self.registry_sources = registry_sources
+
+    def to_dict(self) -> None:
+        super().to_dict()
+
+        if not self.yaml_file:
+            self.res["spec"] = {}
+            _spec = self.res["spec"]
+
+            if self.additional_trusted_ca:
+                _spec["additionalTrustedCA"] = self.additional_trusted_ca
+
+            if self.allowed_registries_for_import:
+                _spec["allowedRegistriesForImport"] = self.allowed_registries_for_import
+
+            if self.external_registry_hostnames:
+                _spec["externalRegistryHostnames"] = self.external_registry_hostnames
+
+            if self.registry_sources:
+                _spec["registrySources"] = self.registry_sources

openshift_python_wrapper-10.0.77/class_generator/tests/manifests/Image/image_image_openshift_io.py

@@ -0,0 +1,132 @@
+# 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 Image(Resource):
+    """
+        Image is an immutable representation of a container image and metadata at a point in time. Images are named by taking a hash of their contents (metadata and content) and any change in format, content, or metadata results in a new name. The images resource is primarily for use by cluster administrators and integrations like the cluster image registry - end users instead access images via the imagestreamtags or imagestreamimages resources. While image metadata is stored in the API, any integration that implements the container image registry API must provide its own storage for the raw manifest data, image config, and layer contents.
+
+    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.IMAGE_OPENSHIFT_IO
+
+    def __init__(
+        self,
+        docker_image_config: Optional[str] = "",
+        docker_image_layers: Optional[List[Any]] = None,
+        docker_image_manifest: Optional[str] = "",
+        docker_image_manifest_media_type: Optional[str] = "",
+        docker_image_manifests: Optional[List[Any]] = None,
+        docker_image_metadata: Optional[Dict[str, Any]] = None,
+        docker_image_metadata_version: Optional[str] = "",
+        docker_image_reference: Optional[str] = "",
+        docker_image_signatures: Optional[List[Any]] = None,
+        signatures: Optional[List[Any]] = None,
+        **kwargs: Any,
+    ) -> None:
+        """
+        Args:
+            docker_image_config(str): DockerImageConfig is a JSON blob that the runtime uses to set up the
+              container. This is a part of manifest schema v2. Will not be set
+              when the image represents a manifest list.
+
+            docker_image_layers(List[Any]): DockerImageLayers represents the layers in the image. May not be set
+              if the image does not define that data or if the image represents
+              a manifest list.
+
+            docker_image_manifest(str): DockerImageManifest is the raw JSON of the manifest
+
+            docker_image_manifest_media_type(str): DockerImageManifestMediaType specifies the mediaType of manifest. This
+              is a part of manifest schema v2.
+
+            docker_image_manifests(List[Any]): DockerImageManifests holds information about sub-manifests when the
+              image represents a manifest list. When this field is present, no
+              DockerImageLayers should be specified.
+
+            docker_image_metadata(Dict[str, Any]): RawExtension is used to hold extensions in external versions.  To use
+              this, make a field which has RawExtension as its type in your
+              external, versioned struct, and Object in your internal struct.
+              You also need to register your various plugin types.  // Internal
+              package:          type MyAPIObject struct {
+              runtime.TypeMeta `json:",inline"`                 MyPlugin
+              runtime.Object `json:"myPlugin"`         }          type PluginA
+              struct {                 AOption string `json:"aOption"`         }
+              // External package:          type MyAPIObject struct {
+              runtime.TypeMeta `json:",inline"`                 MyPlugin
+              runtime.RawExtension `json:"myPlugin"`         }          type
+              PluginA struct {                 AOption string `json:"aOption"`
+              }  // On the wire, the JSON will look something like this:
+              {                 "kind":"MyAPIObject",
+              "apiVersion":"v1",                 "myPlugin": {
+              "kind":"PluginA",                         "aOption":"foo",
+              },         }  So what happens? Decode first uses json or yaml to
+              unmarshal the serialized data into your external MyAPIObject. That
+              causes the raw JSON to be stored, but not unpacked. The next step
+              is to copy (using pkg/conversion) into the internal struct. The
+              runtime package's DefaultScheme has conversion functions installed
+              which will unpack the JSON stored in RawExtension, turning it into
+              the correct object type, and storing it in the Object. (TODO: In
+              the case where the object is of an unknown type, a runtime.Unknown
+              object will be created and stored.)
+
+            docker_image_metadata_version(str): DockerImageMetadataVersion conveys the version of the object, which if
+              empty defaults to "1.0"
+
+            docker_image_reference(str): DockerImageReference is the string that can be used to pull this
+              image.
+
+            docker_image_signatures(List[Any]): DockerImageSignatures provides the signatures as opaque blobs. This is
+              a part of manifest schema v1.
+
+            signatures(List[Any]): Signatures holds all signatures of the image.
+
+        """
+        super().__init__(**kwargs)
+
+        self.docker_image_config = docker_image_config
+        self.docker_image_layers = docker_image_layers
+        self.docker_image_manifest = docker_image_manifest
+        self.docker_image_manifest_media_type = docker_image_manifest_media_type
+        self.docker_image_manifests = docker_image_manifests
+        self.docker_image_metadata = docker_image_metadata
+        self.docker_image_metadata_version = docker_image_metadata_version
+        self.docker_image_reference = docker_image_reference
+        self.docker_image_signatures = docker_image_signatures
+        self.signatures = signatures
+
+    def to_dict(self) -> None:
+        super().to_dict()
+
+        if not self.yaml_file:
+            if self.docker_image_config:
+                self.res["dockerImageConfig"] = self.docker_image_config
+
+            if self.docker_image_layers:
+                self.res["dockerImageLayers"] = self.docker_image_layers
+
+            if self.docker_image_manifest:
+                self.res["dockerImageManifest"] = self.docker_image_manifest
+
+            if self.docker_image_manifest_media_type:
+                self.res["dockerImageManifestMediaType"] = self.docker_image_manifest_media_type
+
+            if self.docker_image_manifests:
+                self.res["dockerImageManifests"] = self.docker_image_manifests
+
+            if self.docker_image_metadata:
+                self.res["dockerImageMetadata"] = self.docker_image_metadata
+
+            if self.docker_image_metadata_version:
+                self.res["dockerImageMetadataVersion"] = self.docker_image_metadata_version
+
+            if self.docker_image_reference:
+                self.res["dockerImageReference"] = self.docker_image_reference
+
+            if self.docker_image_signatures:
+                self.res["dockerImageSignatures"] = self.docker_image_signatures
+
+            if self.signatures:
+                self.res["signatures"] = self.signatures

{openshift_python_wrapper-10.0.76 → openshift_python_wrapper-10.0.77}/class_generator/tests/test_class_generator.py

@@ -21,6 +21,7 @@ from class_generator.class_generator import TESTS_MANIFESTS_DIR, class_generator
         "Pod",
         "Secret",
         "NMState",
+        "Image",
     ),
 )
 def test_parse_explain(tmpdir_factory, kind):

openshift_python_wrapper-10.0.77/ocp_resources/dns.py

@@ -0,0 +1,11 @@
+from warnings import warn
+
+from ocp_resources.dns_config_openshift_io import DNS  # noqa: F401
+
+warn(
+    f"The module {__name__} is deprecated and will be removed in version 4.17, "
+    "`DNS` should be either imported from `ocp_resources.dns_config_openshift_io` "
+    "or `ocp_resources.dns_operator_openshift_io`, depending on the API group.",
+    DeprecationWarning,
+    stacklevel=2,
+)

openshift_python_wrapper-10.0.77/ocp_resources/dns_config_openshift_io.py

@@ -0,0 +1,71 @@
+# 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.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

openshift_python_wrapper-10.0.77/ocp_resources/dns_operator_openshift_io.py

@@ -0,0 +1,120 @@
+# 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.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

openshift_python_wrapper-10.0.77/ocp_resources/image.py

@@ -0,0 +1,11 @@
+from warnings import warn
+
+from ocp_resources.image_image_openshift_io import Image  # noqa: F401
+
+warn(
+    f"The module {__name__} is deprecated and will be removed in version 4.17, "
+    "`Image` should be either imported from `ocp_resources.image_image_openshift_io` or "
+    "`ocp_resources.image_config_openshift_io` depending on the API group.",
+    DeprecationWarning,
+    stacklevel=2,
+)

openshift_python_wrapper-10.0.77/ocp_resources/image_config_openshift_io.py

@@ -0,0 +1,75 @@
+# 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 Image(Resource):
+    """
+       Image governs policies related to imagestream imports and runtime configuration for external registries. It allows cluster admins to configure which registries OpenShift is allowed to import images from, extra CA trust bundles for external registries, and policies to block or allow registry hostnames. When exposing OpenShift's image registry to the public, this also lets cluster admins specify the external hostname.
+    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_trusted_ca: Optional[Dict[str, Any]] = None,
+        allowed_registries_for_import: Optional[List[Any]] = None,
+        external_registry_hostnames: Optional[List[Any]] = None,
+        registry_sources: Optional[Dict[str, Any]] = None,
+        **kwargs: Any,
+    ) -> None:
+        """
+        Args:
+            additional_trusted_ca(Dict[str, Any]): additionalTrustedCA is a reference to a ConfigMap containing
+              additional CAs that should be trusted during imagestream import,
+              pod image pull, build image pull, and imageregistry pullthrough.
+              The namespace for this config map is openshift-config.
+
+            allowed_registries_for_import(List[Any]): allowedRegistriesForImport limits the container image registries that
+              normal users may import images from. Set this list to the
+              registries that you trust to contain valid Docker images and that
+              you want applications to be able to import from. Users with
+              permission to create Images or ImageStreamMappings via the API are
+              not affected by this policy - typically only administrators or
+              system integrations will have those permissions.
+
+            external_registry_hostnames(List[Any]): externalRegistryHostnames provides the hostnames for the default
+              external image registry. The external hostname should be set only
+              when the image registry is exposed externally. The first value is
+              used in 'publicDockerImageRepository' field in ImageStreams. The
+              value must be in "hostname[:port]" format.
+
+            registry_sources(Dict[str, Any]): registrySources contains configuration that determines how the
+              container runtime should treat individual registries when
+              accessing images for builds+pods. (e.g. whether or not to allow
+              insecure access).  It does not contain configuration for the
+              internal cluster registry.
+
+        """
+        super().__init__(**kwargs)
+
+        self.additional_trusted_ca = additional_trusted_ca
+        self.allowed_registries_for_import = allowed_registries_for_import
+        self.external_registry_hostnames = external_registry_hostnames
+        self.registry_sources = registry_sources
+
+    def to_dict(self) -> None:
+        super().to_dict()
+
+        if not self.yaml_file:
+            self.res["spec"] = {}
+            _spec = self.res["spec"]
+
+            if self.additional_trusted_ca:
+                _spec["additionalTrustedCA"] = self.additional_trusted_ca
+
+            if self.allowed_registries_for_import:
+                _spec["allowedRegistriesForImport"] = self.allowed_registries_for_import
+
+            if self.external_registry_hostnames:
+                _spec["externalRegistryHostnames"] = self.external_registry_hostnames
+
+            if self.registry_sources:
+                _spec["registrySources"] = self.registry_sources