kubernator 1.0.21.dev20250528230808__tar.gz → 1.0.23__tar.gz

{kubernator-1.0.21.dev20250528230808 → kubernator-1.0.23}/PKG-INFO

@@ -1,23 +1,23 @@
 Metadata-Version: 2.4
 Name: kubernator
-Version: 1.0.21.dev20250528230808
+Version: 1.0.23
 Summary: Kubernator is the a pluggable framework for K8S provisioning
 Home-page: https://github.com/karellen/kubernator
 Author: Express Systems USA, Inc.
 Author-email: 
 Maintainer: Karellen, Inc., Arcadiy Ivanov
 Maintainer-email: supervisor@karellen.co,arcadiy@karellen.co
-License: Apache License, Version 2.0
+License: Apache-2.0
 Project-URL: Bug Tracker, https://github.com/karellen/kubernator/issues
 Project-URL: Documentation, https://github.com/karellen/kubernator/
 Project-URL: Source Code, https://github.com/karellen/kubernator/
 Keywords: kubernetes k8s kube top provisioning kOps terraform tf AWS
-Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Operating System :: MacOS :: MacOS X
 Classifier: Operating System :: POSIX
 Classifier: Operating System :: POSIX :: Linux
@@ -45,7 +45,7 @@ Requires-Dist: kubernetes~=32.0
 Requires-Dist: openapi-schema-validator~=0.1
 Requires-Dist: openapi-spec-validator~=0.3
 Requires-Dist: platformdirs~=4.2
-Requires-Dist: requests<=2.31.0
+Requires-Dist: requests>=2.31.0
 Dynamic: author
 Dynamic: classifier
 Dynamic: description

{kubernator-1.0.21.dev20250528230808 → kubernator-1.0.23}/kubernator/__init__.py

@@ -16,7 +16,7 @@
 #   limitations under the License.
 #
 
-__version__ = "1.0.21.dev20250528230808"
+__version__ = "1.0.23"
 
 
 def _main():

{kubernator-1.0.21.dev20250528230808 → kubernator-1.0.23}/kubernator/api.py

@@ -20,6 +20,7 @@ import fnmatch
 import json
 import logging
 import os
+import io
 import platform
 import re
 import sys
@@ -58,6 +59,53 @@ _CACHE_HEADER_TRANSLATION = {"etag": "if-none-match",
 _CACHE_HEADERS = ("etag", "last-modified")
 
 
+class TemplateEngine:
+    VARIABLE_START_STRING = "{${"
+    VARIABLE_END_STRING = "}$}"
+
+    def __init__(self, logger):
+        self.template_failures = 0
+        self.templates = {}
+
+        class CollectingUndefined(ChainableUndefined):
+            __slots__ = ()
+
+            def __str__(self):
+                self.template_failures += 1
+                return super().__str__()
+
+        logging_undefined = make_logging_undefined(
+            logger=logger,
+            base=CollectingUndefined
+        )
+
+        @pass_context
+        def variable_finalizer(ctx, value):
+            normalized_value = str(value)
+            if self.VARIABLE_START_STRING in normalized_value and self.VARIABLE_END_STRING in normalized_value:
+                value_template_content = sys.intern(normalized_value)
+                env: Environment = ctx.environment
+                value_template = self.templates.get(value_template_content)
+                if not value_template:
+                    value_template = env.from_string(value_template_content, env.globals)
+                    self.templates[value_template_content] = value_template
+                return value_template.render(ctx.parent)
+
+            return normalized_value
+
+        self.env = Environment(variable_start_string=self.VARIABLE_START_STRING,
+                               variable_end_string=self.VARIABLE_END_STRING,
+                               autoescape=False,
+                               finalize=variable_finalizer,
+                               undefined=logging_undefined)
+
+    def from_string(self, template):
+        return self.env.from_string(template)
+
+    def failures(self):
+        return self.template_failures
+
+
 def calling_frame_source(depth=2):
     f = traceback.extract_stack(limit=depth + 1)[0]
     return f"file {f.filename}, line {f.lineno} in {f.name}"
@@ -96,9 +144,15 @@ class FileType(Enum):
         self.func = func
 
 
-def _load_file(logger, path: Path, file_type: FileType, source=None) -> Iterable[dict]:
-    with open(path, "rb") as f:
+def _load_file(logger, path: Path, file_type: FileType, source=None,
+               template_engine: Optional[TemplateEngine] = None,
+               template_context: Optional[dict] = None) -> Iterable[dict]:
+    with open(path, "rb" if not template_engine else "rt") as f:
         try:
+            if template_engine:
+                raw_data = template_engine.from_string(f.read()).render(template_context)
+                f.close()
+                f = io.StringIO(raw_data)
             data = file_type.func(f)
             if isinstance(data, GeneratorType):
                 data = list(data)
@@ -191,9 +245,12 @@ def load_remote_file(logger, url, file_type: FileType, category: str = "k8s", su
     return _load_file(logger, file_name, file_type, url)
 
 
-def load_file(logger, path: Path, file_type: FileType, source=None) -> Iterable[dict]:
+def load_file(logger, path: Path, file_type: FileType, source=None,
+              template_engine: Optional[TemplateEngine] = None,
+              template_context: Optional[dict] = None) -> Iterable[dict]:
     logger.debug("Loading %s using %s", source or path, file_type.name)
-    return _load_file(logger, path, file_type)
+    return _load_file(logger, path, file_type,
+                      source, template_engine, template_context)
 
 
 def validator_with_defaults(validator_class):
@@ -513,53 +570,6 @@ class Globs(MutableSet[Union[str, re.Pattern]]):
         return f"Globs[{self._list}]"
 
 
-class TemplateEngine:
-    VARIABLE_START_STRING = "{${"
-    VARIABLE_END_STRING = "}$}"
-
-    def __init__(self, logger):
-        self.template_failures = 0
-        self.templates = {}
-
-        class CollectingUndefined(ChainableUndefined):
-            __slots__ = ()
-
-            def __str__(self):
-                self.template_failures += 1
-                return super().__str__()
-
-        logging_undefined = make_logging_undefined(
-            logger=logger,
-            base=CollectingUndefined
-        )
-
-        @pass_context
-        def variable_finalizer(ctx, value):
-            normalized_value = str(value)
-            if self.VARIABLE_START_STRING in normalized_value and self.VARIABLE_END_STRING in normalized_value:
-                value_template_content = sys.intern(normalized_value)
-                env: Environment = ctx.environment
-                value_template = self.templates.get(value_template_content)
-                if not value_template:
-                    value_template = env.from_string(value_template_content, env.globals)
-                    self.templates[value_template_content] = value_template
-                return value_template.render(ctx.parent)
-
-            return normalized_value
-
-        self.env = Environment(variable_start_string=self.VARIABLE_START_STRING,
-                               variable_end_string=self.VARIABLE_END_STRING,
-                               autoescape=False,
-                               finalize=variable_finalizer,
-                               undefined=logging_undefined)
-
-    def from_string(self, template):
-        return self.env.from_string(template)
-
-    def failures(self):
-        return self.template_failures
-
-
 class Template:
     def __init__(self, name: str, template: JinjaTemplate, defaults: dict = None, path=None, source=None):
         self.name = name
@@ -768,7 +778,8 @@ class KubernatorPlugin:
         pass
 
 
-def install_python_k8s_client(run, package_major, logger, logger_stdout, logger_stderr, disable_patching):
+def install_python_k8s_client(run, package_major, logger, logger_stdout, logger_stderr, disable_patching,
+                              fallback=False):
     cache_dir = get_cache_dir("python")
     package_major_dir = cache_dir / str(package_major)
     package_major_dir_str = str(package_major_dir)
@@ -780,14 +791,43 @@ def install_python_k8s_client(run, package_major, logger, logger_stdout, logger_
                     str(package_major), package_major_dir)
         rmtree(package_major_dir)
 
-    if not package_major_dir.exists():
+    if not package_major_dir.exists() or not len(os.listdir(package_major_dir)):
         package_major_dir.mkdir(parents=True, exist_ok=True)
-        run([sys.executable, "-m", "pip", "install", "--no-deps", "--no-input",
-             "--root-user-action=ignore", "--break-system-packages", "--disable-pip-version-check",
-             "--target", package_major_dir_str, f"kubernetes>={package_major!s}dev0,<{int(package_major) + 1!s}"],
-            logger_stdout, logger_stderr).wait()
+        try:
+            run([sys.executable, "-m", "pip", "install", "--no-deps", "--no-input",
+                 "--root-user-action=ignore", "--break-system-packages", "--disable-pip-version-check",
+                 "--target", package_major_dir_str, f"kubernetes>={package_major!s}dev0,<{int(package_major) + 1!s}"],
+                logger_stdout, logger_stderr)
+        except CalledProcessError as e:
+            if not fallback and "No matching distribution found for" in e.stderr:
+                logger.warning("Kubernetes Client %s (%s) failed to install because the version wasn't found. "
+                               "Falling back to a client of the previous version - %s",
+                               str(package_major), package_major_dir, int(package_major) - 1)
+                return install_python_k8s_client(run,
+                                                 int(package_major) - 1,
+                                                 logger,
+                                                 logger_stdout,
+                                                 logger_stderr,
+                                                 disable_patching,
+                                                 fallback=True)
+            else:
+                raise
 
     if not patch_indicator.exists() and not disable_patching:
+        if not fallback and not len(os.listdir(package_major_dir)):
+            # Directory is empty
+            logger.warning("Kubernetes Client %s (%s) directory is empty - the client was not installed. "
+                           "Falling back to a client of the previous version - %s",
+                           str(package_major), package_major_dir, int(package_major) - 1)
+
+            return install_python_k8s_client(run,
+                                             int(package_major) - 1,
+                                             logger,
+                                             logger_stdout,
+                                             logger_stderr,
+                                             disable_patching,
+                                             fallback=True)
+
         for patch_text, target_file, skip_if_found, min_version, max_version, name in (
                 URLLIB_HEADERS_PATCH, CUSTOM_OBJECT_PATCH_23, CUSTOM_OBJECT_PATCH_25):
             patch_target = package_major_dir / target_file

{kubernator-1.0.21.dev20250528230808 → kubernator-1.0.23}/kubernator/app.py

@@ -35,7 +35,7 @@ import kubernator
 from kubernator.api import (KubernatorPlugin, Globs, scan_dir, PropertyDict, config_as_dict, config_parent,
                             download_remote_file, load_remote_file, Repository, StripNL, jp, get_app_cache_dir,
                             get_cache_dir, install_python_k8s_client)
-from kubernator.proc import run, run_capturing_out
+from kubernator.proc import run, run_capturing_out, run_pass_through_capturing
 
 TRACE = 5
 
@@ -215,7 +215,7 @@ class App(KubernatorPlugin):
                 self.context = self._top_dir_context
                 context = self.context
                 self._run_handlers(KubernatorPlugin.handle_shutdown, True, context, None)
-        except: # noqa E722
+        except:  # noqa E722
             raise
         else:
             self.context = self._top_dir_context
@@ -348,6 +348,7 @@ class App(KubernatorPlugin):
                                    jp=jp,
                                    run=self._run,
                                    run_capturing_out=self._run_capturing_out,
+                                   run_passthrough_capturing=self._run_passthrough_capturing,
                                    repository=self.repository,
                                    StripNL=StripNL,
                                    default_includes=Globs(["*"], True),
@@ -465,6 +466,9 @@ class App(KubernatorPlugin):
     def _run_capturing_out(self, *args, **kwargs):
         return run_capturing_out(*args, **kwargs)
 
+    def _run_passthrough_capturing(self, *args, **kwargs):
+        return run_pass_through_capturing(*args, **kwargs)
+
     def __repr__(self):
         return "Kubernator"
 
@@ -493,7 +497,7 @@ def pre_cache_k8s_clients(*versions, disable_patching=False):
     for v in versions:
         logger.info("Caching K8S client library ~=v%s.0%s...", v,
                     " (no patches)" if disable_patching else "")
-        install_python_k8s_client(run, v, logger, stdout_logger, stderr_logger, disable_patching)
+        install_python_k8s_client(run_pass_through_capturing, v, logger, stdout_logger, stderr_logger, disable_patching)
 
 
 def main():

kubernator-1.0.23/kubernator/plugins/gke.py

@@ -0,0 +1,105 @@
+# -*- coding: utf-8 -*-
+#
+#   Copyright 2020 Express Systems USA, Inc
+#   Copyright 2025 Karellen, Inc.
+#
+#   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.
+#
+
+import logging
+import os
+import tempfile
+from pathlib import Path
+from shutil import which
+
+from kubernator.api import (KubernatorPlugin,
+                            StripNL
+                            )
+
+logger = logging.getLogger("kubernator.gke")
+proc_logger = logger.getChild("proc")
+stdout_logger = StripNL(proc_logger.info)
+stderr_logger = StripNL(proc_logger.warning)
+
+
+class GkePlugin(KubernatorPlugin):
+    logger = logger
+
+    _name = "gke"
+
+    def __init__(self):
+        self.context = None
+        self.kubeconfig_dir = tempfile.TemporaryDirectory()
+        self.name = None
+        self.region = None
+        self.project = None
+        self.gcloud_file = None
+
+        super().__init__()
+
+    def set_context(self, context):
+        self.context = context
+
+    def register(self, *, name=None, region=None, project=None):
+        context = self.context
+
+        if not name:
+            raise ValueError("`name` is required")
+        if not region:
+            raise ValueError("`region` is required")
+        if not project:
+            raise ValueError("`project` is required")
+
+        self.name = name
+        self.region = region
+        self.project = project
+
+        # Use current version
+        gcloud_file = which("gcloud")
+        if not gcloud_file:
+            raise RuntimeError("`gcloud` cannot be found")
+        logger.debug("Found gcloud in %r", gcloud_file)
+        self.gcloud_file = gcloud_file
+
+        context.app.register_plugin("kubeconfig")
+
+        context.globals.gke = dict(kubeconfig=str(Path(self.kubeconfig_dir.name) / "config"),
+                                   name=name,
+                                   region=region,
+                                   project=project,
+                                   gcloud_file=gcloud_file
+                                   )
+
+    def handle_init(self):
+        context = self.context
+
+        env = dict(os.environ)
+        env["KUBECONFIG"] = str(context.gke.kubeconfig)
+        self.context.app.run([context.gke.gcloud_file, "components", "install", "gke-gcloud-auth-plugin"],
+                             stdout_logger,
+                             stderr_logger).wait()
+        self.context.app.run([context.gke.gcloud_file, "container", "clusters", "get-credentials",
+                              context.gke.name,
+                              "--region", context.gke.region,
+                              "--project", context.gke.project],
+                             stdout_logger,
+                             stderr_logger,
+                             env=env).wait()
+
+        context.kubeconfig.set(context.gke.kubeconfig)
+
+    def handle_shutdown(self):
+        self.kubeconfig_dir.cleanup()
+
+    def __repr__(self):
+        return "GKE Plugin"

{kubernator-1.0.21.dev20250528230808 → kubernator-1.0.23}/kubernator/plugins/helm.py

@@ -37,7 +37,7 @@ from kubernator.api import (KubernatorPlugin, Globs, StripNL,
                             validator_with_defaults,
                             get_golang_os,
                             get_golang_machine,
-                            prepend_os_path
+                            prepend_os_path, TemplateEngine
                             )
 from kubernator.plugins.k8s_api import K8SResource
 from kubernator.proc import DEVNULL
@@ -102,6 +102,7 @@ class HelmPlugin(KubernatorPlugin):
         self.context = None
         self.repositories = set()
         self.helm_dir = None
+        self.template_engine = TemplateEngine(logger)
 
     def set_context(self, context):
         self.context = context
@@ -180,7 +181,9 @@ class HelmPlugin(KubernatorPlugin):
             display_p = context.app.display_path(p)
             logger.debug("Adding Helm template from %s", display_p)
 
-            helm_templates = load_file(logger, p, FileType.YAML, display_p)
+            helm_templates = load_file(logger, p, FileType.YAML, display_p,
+                                       self.template_engine,
+                                       {"ktor": context})
 
             for helm_template in helm_templates:
                 self._add_helm(helm_template, display_p)
@@ -232,6 +235,17 @@ class HelmPlugin(KubernatorPlugin):
             values_file = Path(values_file)
             if not values_file.is_absolute():
                 values_file = self.context.app.cwd / values_file
+            values = list(load_file(logger, values_file, FileType.YAML,
+                                    template_engine=self.template_engine,
+                                    template_context={"ktor": self.context,
+                                                      "helm": {"chart": chart,
+                                                               "name": name,
+                                                               "namespace": namespace,
+                                                               "include_crds": include_crds,
+                                                               "repository": repository,
+                                                               "version": version,
+                                                               }}))
+            values = values[0] if values else {}
 
         version_spec = []
         if repository:
@@ -260,8 +274,7 @@ class HelmPlugin(KubernatorPlugin):
                                                         ] +
                                                        version_spec +
                                                        (["--include-crds"] if include_crds else []) +
-                                                       (["-f", values_file] if values_file else []) +
-                                                       (["-f", "-"] if values else []),
+                                                       ["-f", "-"],
                                                        stderr_logger,
                                                        stdin=stdin,
                                                        )

{kubernator-1.0.21.dev20250528230808 → kubernator-1.0.23}/kubernator/plugins/istio.py

@@ -25,6 +25,7 @@ from pathlib import Path
 from shutil import which
 
 import yaml
+
 from kubernator.api import (KubernatorPlugin, scan_dir,
                             TemplateEngine,
                             load_remote_file,
@@ -33,7 +34,8 @@ from kubernator.api import (KubernatorPlugin, scan_dir,
                             Globs,
                             get_golang_os,
                             get_golang_machine,
-                            prepend_os_path, jp)
+                            prepend_os_path, jp, load_file)
+from kubernator.plugins.k8s import api_exc_normalize_body, api_exc_format_body
 from kubernator.plugins.k8s_api import K8SResourcePluginMixin
 
 logger = logging.getLogger("kubernator.istio")
@@ -210,10 +212,11 @@ class IstioPlugin(KubernatorPlugin, K8SResourcePluginMixin):
             display_p = context.app.display_path(p)
             logger.info("Adding Istio Operator from %s", display_p)
 
-            with open(p, "rt") as file:
-                template = self.template_engine.from_string(file.read())
+            manifests = load_file(logger, p, FileType.YAML, display_p,
+                                  self.template_engine,
+                                  {"ktor": context})
 
-            self.add_resources(template.render({"ktor": context}), display_p)
+            self.add_resources(manifests, display_p)
 
     def handle_apply(self):
         context = self.context
@@ -276,11 +279,17 @@ class IstioPlugin(KubernatorPlugin, K8SResourcePluginMixin):
         try:
             res.delete(dry_run=dry_run)
         except ApiException as e:
-            skip = False
-            if e.status == 404 and missing_ok:
-                skip = True
-            if not skip:
+            api_exc_normalize_body(e)
+            try:
+                skip = False
+                if e.status == 404 and missing_ok:
+                    skip = True
+                if not skip:
+                    raise
+            except ApiException as e:
+                api_exc_format_body(e)
                 raise
+
         return res
 
     def _create_resource_internal(self, manifest, dry_run=True, exists_ok=False):
@@ -296,12 +305,18 @@ class IstioPlugin(KubernatorPlugin, K8SResourcePluginMixin):
             res.create(dry_run=dry_run)
         except ApiException as e:
             skip = False
-            if e.status == 409:
-                status = json.loads(e.body)
-                if status["reason"] == "AlreadyExists" and exists_ok:
-                    skip = True
-            if not skip:
+            api_exc_normalize_body(e)
+            try:
+                if e.status == 409:
+                    status = e.body
+                    if status["reason"] == "AlreadyExists" and exists_ok:
+                        skip = True
+                if not skip:
+                    raise
+            except ApiException as e:
+                api_exc_format_body(e)
                 raise
+
         return res
 
     def _install(self, operators_file, dry_run):

{kubernator-1.0.21.dev20250528230808 → kubernator-1.0.23}/kubernator/plugins/k8s.py

@@ -30,6 +30,7 @@ from typing import Iterable, Callable, Sequence
 
 import jsonpatch
 import yaml
+from kubernetes.client import ApiException
 
 from kubernator.api import (KubernatorPlugin,
                             Globs,
@@ -38,7 +39,9 @@ from kubernator.api import (KubernatorPlugin,
                             FileType,
                             load_remote_file,
                             StripNL,
-                            install_python_k8s_client)
+                            install_python_k8s_client,
+                            TemplateEngine,
+                            sleep)
 from kubernator.merge import extract_merge_instructions, apply_merge_instructions
 from kubernator.plugins.k8s_api import (K8SResourcePluginMixin,
                                         K8SResource,
@@ -81,6 +84,21 @@ def normalize_pkg_version(v: str):
     return tuple(map(int, v_split))
 
 
+def api_exc_normalize_body(e: "ApiException"):
+    if e.headers and "content-type" in e.headers:
+        content_type = e.headers["content-type"]
+        if content_type == "application/json" or content_type.endswith("+json"):
+            e.body = json.loads(e.body)
+        elif (content_type in ("application/yaml", "application/x-yaml", "text/yaml",
+                               "text/x-yaml") or content_type.endswith("+yaml")):
+            e.body = yaml.safe_load(e.body)
+
+
+def api_exc_format_body(e: ApiException):
+    if not isinstance(e.body, (str, bytes)):
+        e.body = json.dumps(e.body, indent=4)
+
+
 class KubernetesPlugin(KubernatorPlugin, K8SResourcePluginMixin):
     logger = logger
 
@@ -95,6 +113,7 @@ class KubernetesPlugin(KubernatorPlugin, K8SResourcePluginMixin):
         self._transformers = []
         self._validators = []
         self._summary = 0, 0, 0
+        self._template_engine = TemplateEngine(logger)
 
     def set_context(self, context):
         self.context = context
@@ -118,6 +137,8 @@ class KubernetesPlugin(KubernatorPlugin, K8SResourcePluginMixin):
                                                       ("apps", "StatefulSet"): K8SPropagationPolicy.ORPHAN,
                                                       ("apps", "Deployment"): K8SPropagationPolicy.ORPHAN,
                                                       ("storage.k8s.io", "StorageClass"): K8SPropagationPolicy.ORPHAN,
+                                                      (None, "Pod"): K8SPropagationPolicy.BACKGROUND,
+                                                      ("batch", "Job"): K8SPropagationPolicy.ORPHAN,
                                                       },
                                    default_includes=Globs(["*.yaml", "*.yml"], True),
                                    default_excludes=Globs([".*"], True),
@@ -135,6 +156,7 @@ class KubernetesPlugin(KubernatorPlugin, K8SResourcePluginMixin):
                                    field_validation=field_validation,
                                    field_validation_warn_fatal=field_validation_warn_fatal,
                                    field_validation_warnings=0,
+                                   conflict_retry_delay=0.3,
                                    _k8s=self,
                                    )
         context.k8s = dict(default_includes=Globs(context.globals.k8s.default_includes),
@@ -164,7 +186,7 @@ class KubernetesPlugin(KubernatorPlugin, K8SResourcePluginMixin):
 
         logger.info("Using Kubernetes client version =~%s.0 for server version %s",
                     server_minor, ".".join(k8s.server_version))
-        pkg_dir = install_python_k8s_client(self.context.app.run, server_minor, logger,
+        pkg_dir = install_python_k8s_client(self.context.app.run_passthrough_capturing, server_minor, logger,
                                             stdout_logger, stderr_logger, k8s.disable_client_patches)
 
         modules_to_delete = []
@@ -197,7 +219,7 @@ class KubernetesPlugin(KubernatorPlugin, K8SResourcePluginMixin):
 
         k8s.client = self._setup_k8s_client()
         version = client.VersionApi(k8s.client).get_code()
-        if "-eks-" in version.git_version:
+        if "-eks-" or "-gke" in version.git_version:
             git_version = version.git_version.split("-")[0]
         else:
             git_version = version.git_version
@@ -239,7 +261,10 @@ class KubernetesPlugin(KubernatorPlugin, K8SResourcePluginMixin):
             display_p = context.app.display_path(p)
             logger.debug("Adding Kubernetes manifest from %s", display_p)
 
-            manifests = load_file(logger, p, FileType.YAML, display_p)
+            manifests = load_file(logger, p, FileType.YAML, display_p,
+                                  self._template_engine,
+                                  {"ktor": context}
+                                  )
 
             for manifest in manifests:
                 if manifest:
@@ -404,8 +429,8 @@ class KubernetesPlugin(KubernatorPlugin, K8SResourcePluginMixin):
 
         def handle_400_strict_validation_error(e: ApiException):
             if e.status == 400:
-                status = json.loads(e.body)
-
+                # Assumes the body has been parsed
+                status = e.body
                 if status["status"] == "Failure":
                     if FIELD_VALIDATION_STRICT_MARKER in status["message"]:
                         message = status["message"]
@@ -420,18 +445,31 @@ class KubernetesPlugin(KubernatorPlugin, K8SResourcePluginMixin):
                                      resource, resource.source, status["message"])
                         raise e from None
 
-        def create(exists_ok=False):
+        def create(exists_ok=False, wait_for_delete=False):
             logger.info("Creating resource %s%s%s", resource, status_msg,
                         " (ignoring existing)" if exists_ok else "")
-            try:
-                create_func()
-            except ApiException as e:
-                if exists_ok:
-                    if e.status == 409:
-                        status = json.loads(e.body)
-                        if status["reason"] == "AlreadyExists":
-                            return
-                raise
+            while True:
+                try:
+                    create_func()
+                    return
+                except ApiException as __e:
+                    api_exc_normalize_body(__e)
+                    try:
+                        if exists_ok or wait_for_delete:
+                            if __e.status == 409:
+                                status = __e.body
+                                if status["reason"] == "AlreadyExists":
+                                    if wait_for_delete:
+                                        sleep(self.context.k8s.conflict_retry_delay)
+                                        logger.info("Retry creating resource %s%s%s", resource, status_msg,
+                                                    " (ignoring existing)" if exists_ok else "")
+                                        continue
+                                    else:
+                                        return
+                        raise
+                    except ApiException as ___e:
+                        api_exc_format_body(___e)
+                        raise
 
         merge_instrs, normalized_manifest = extract_merge_instructions(resource.manifest, resource)
         if merge_instrs:
@@ -445,15 +483,20 @@ class KubernetesPlugin(KubernatorPlugin, K8SResourcePluginMixin):
             remote_resource = resource.get()
             logger.trace("Current resource %s: %s", resource, remote_resource)
         except ApiException as e:
-            if e.status == 404:
-                try:
-                    create()
-                    return 1, 0, 0
-                except ApiException as e:
-                    if not handle_400_strict_validation_error(e):
-                        raise
-
-            else:
+            api_exc_normalize_body(e)
+            try:
+                if e.status == 404:
+                    try:
+                        create()
+                        return 1, 0, 0
+                    except ApiException as e:
+                        api_exc_normalize_body(e)
+                        if not handle_400_strict_validation_error(e):
+                            raise
+                else:
+                    raise
+            except ApiException as _e:
+                api_exc_format_body(_e)
                 raise
         else:
             logger.trace("Attempting to retrieve a normalized patch for resource %s: %s", resource, normalized_manifest)
@@ -463,34 +506,44 @@ class KubernetesPlugin(KubernatorPlugin, K8SResourcePluginMixin):
                                                  dry_run=True,
                                                  force=True)
             except ApiException as e:
-                if e.status == 422:
-                    status = json.loads(e.body)
-                    details = status["details"]
-                    immutable_key = details["group"], details["kind"]
-
-                    try:
-                        propagation_policy = self.context.k8s.immutable_changes[immutable_key]
-                    except KeyError:
-                        raise e from None
+                try:
+                    api_exc_normalize_body(e)
+
+                    if e.status == 422:
+                        status = e.body
+                        # Assumes the body has been unmarshalled
+                        details = status["details"]
+                        immutable_key = details.get("group"), details["kind"]
+
+                        try:
+                            propagation_policy = self.context.k8s.immutable_changes[immutable_key]
+                        except KeyError:
+                            raise e from None
+                        else:
+                            for cause in details["causes"]:
+                                if (
+                                        cause["reason"] == "FieldValueInvalid" and
+                                        "field is immutable" in cause["message"]
+                                        or
+                                        cause["reason"] == "FieldValueForbidden" and
+                                        ("Forbidden: updates to" in cause["message"]
+                                         or
+                                         "Forbidden: pod updates" in cause["message"])
+                                ):
+                                    logger.info("Deleting resource %s (cascade %s)%s", resource,
+                                                propagation_policy.policy,
+                                                status_msg)
+                                    delete_func(propagation_policy=propagation_policy)
+                                    create(exists_ok=dry_run, wait_for_delete=not dry_run)
+                                    return 1, 0, 1
+                            raise
                     else:
-                        for cause in details["causes"]:
-                            if (
-                                    cause["reason"] == "FieldValueInvalid" and
-                                    "field is immutable" in cause["message"]
-                                    or
-                                    cause["reason"] == "FieldValueForbidden" and
-                                    "Forbidden: updates to" in cause["message"]
-                            ):
-                                logger.info("Deleting resource %s (cascade %s)%s", resource,
-                                            propagation_policy.policy,
-                                            status_msg)
-                                delete_func(propagation_policy=propagation_policy)
-                                create(exists_ok=dry_run)
-                                return 1, 0, 1
-                        raise
-                else:
-                    if not handle_400_strict_validation_error(e):
-                        raise
+                        if not handle_400_strict_validation_error(e):
+                            raise
+                except ApiException as _e:
+                    api_exc_format_body(_e)
+                    raise
+
             else:
                 logger.trace("Merged resource %s: %s", resource, merged_resource)
                 if merge_instrs:

{kubernator-1.0.21.dev20250528230808 → kubernator-1.0.23}/kubernator/plugins/k8s_api.py

@@ -116,22 +116,22 @@ k8s_format_checker = FormatChecker()
 
 @k8s_format_checker.checks("int32")
 def check_int32(value):
-    return -2147483648 < value < 2147483647
+    return value is not None and (-2147483648 < value < 2147483647)
 
 
 @k8s_format_checker.checks("int64")
 def check_int64(value):
-    return -9223372036854775808 < value < 9223372036854775807
+    return value is not None and (-9223372036854775808 < value < 9223372036854775807)
 
 
 @k8s_format_checker.checks("float")
 def check_float(value):
-    return -3.4E+38 < value < +3.4E+38
+    return value is not None and (-3.4E+38 < value < +3.4E+38)
 
 
 @k8s_format_checker.checks("double")
 def check_double(value):
-    return -1.7E+308 < value < +1.7E+308
+    return value is not None and (-1.7E+308 < value < +1.7E+308)
 
 
 @k8s_format_checker.checks("byte", ValueError)
@@ -619,9 +619,9 @@ class K8SResourcePluginMixin:
         errors = list(self._validate_resource(manifest, source))
         if errors:
             for error in errors:
-                if source:
-                    self.logger.error("Error detected in K8S manifest %s from %s",
-                                      resource_description, source, exc_info=error)
+                self.logger.error("Error detected in K8S manifest %s from %s: \n%s",
+                                  resource_description, source or "<unknown>", yaml.safe_dump(manifest, None),
+                                  exc_info=error)
             raise errors[0]
 
         rdef = self._get_manifest_rdef(manifest)

{kubernator-1.0.21.dev20250528230808 → kubernator-1.0.23}/kubernator/plugins/kops.py

@@ -30,7 +30,7 @@ from kubernator.api import (KubernatorPlugin, scan_dir,
                             io_StringIO,
                             TemplateEngine,
                             StripNL,
-                            Globs)
+                            Globs, load_file)
 from kubernator.plugins.k8s_api import K8SResourcePluginMixin
 from kubernator.proc import CalledProcessError
 
@@ -136,10 +136,11 @@ class KopsPlugin(KubernatorPlugin, K8SResourcePluginMixin):
             display_p = context.app.display_path(p)
             logger.debug("Adding Kops resources from %s", display_p)
 
-            with open(p, "rt") as file:
-                template = self.template_engine.from_string(file.read())
+            manifests = load_file(logger, p, FileType.YAML, display_p,
+                                  self.template_engine,
+                                  {"ktor": context})
 
-            self.add_resources(template.render({"ktor": context}), display_p)
+            self.add_resources(manifests, display_p)
 
     def update(self):
         context = self.context

{kubernator-1.0.21.dev20250528230808 → kubernator-1.0.23}/kubernator/plugins/kubectl.py

@@ -16,6 +16,7 @@
 #   limitations under the License.
 #
 
+import io
 import json
 import logging
 import os
@@ -23,6 +24,8 @@ import tempfile
 from pathlib import Path
 from shutil import which, copy
 
+import yaml
+
 from kubernator.api import (KubernatorPlugin,
                             prepend_os_path,
                             StripNL,
@@ -89,15 +92,44 @@ class KubectlPlugin(KubernatorPlugin):
         context.globals.kubectl = dict(version=version,
                                        kubectl_file=kubectl_file,
                                        stanza=self.stanza,
-                                       test=self.test_kubectl
+                                       test=self.test_kubectl,
+                                       run=self.run,
+                                       run_capturing=self.run_capturing,
+                                       get=self.get,
                                        )
 
         context.globals.kubectl.version = context.kubectl.test()
 
+    def run_capturing(self, *args, **kwargs):
+        return self.context.app.run_capturing_out(self.stanza() +
+                                                  list(args),
+                                                  stderr_logger,
+                                                  **kwargs
+                                                  )
+
+    def run(self, *args, **kwargs):
+        self.context.app.run(self.stanza() +
+                             list(args),
+                             stdout_logger,
+                             stderr_logger,
+                             **kwargs
+                             ).wait()
+
+    def get(self, resource_type, resource_name, namespace=None):
+        args = ["get", resource_type, resource_name]
+        if namespace:
+            args += ["-n", namespace]
+        args += ["-o", "yaml"]
+
+        res = list(yaml.safe_load_all(io.StringIO(self.context.kubectl.run_capturing(*args))))
+        if len(res):
+            if len(res) > 1:
+                return res
+            return res[0]
+        return None
+
     def test_kubectl(self):
-        version_out: str = self.context.app.run_capturing_out(self.stanza() +
-                                                              ["version", "--client=true", "-o", "json"],
-                                                              stderr_logger)
+        version_out: str = self.run_capturing("version", "--client=true", "-o", "json")
 
         version_out_js = json.loads(version_out)
         kubectl_version = version_out_js["clientVersion"]["gitVersion"][1:]

{kubernator-1.0.21.dev20250528230808 → kubernator-1.0.23}/kubernator/plugins/minikube.py

@@ -15,7 +15,7 @@
 #   See the License for the specific language governing permissions and
 #   limitations under the License.
 #
-
+import json
 import logging
 import os
 import tempfile
@@ -35,6 +35,8 @@ proc_logger = logger.getChild("proc")
 stdout_logger = StripNL(proc_logger.info)
 stderr_logger = StripNL(proc_logger.warning)
 
+MINIKUBE_MAX_VERSION_LEGACY = "1.36.0"
+
 
 class MinikubePlugin(KubernatorPlugin):
     logger = logger
@@ -89,7 +91,7 @@ class MinikubePlugin(KubernatorPlugin):
 
     def register(self, minikube_version=None, profile="default", k8s_version=None,
                  keep_running=False, start_fresh=False,
-                 nodes=1, driver=None, cpus="no-limit", extra_args=None):
+                 nodes=1, driver=None, cpus="no-limit", extra_args=None, extra_addons=None):
         context = self.context
 
         context.app.register_plugin("kubeconfig")
@@ -99,9 +101,17 @@ class MinikubePlugin(KubernatorPlugin):
             logger.critical(msg)
             raise RuntimeError(msg)
 
+        k8s_version_tuple = tuple(map(int, k8s_version.split(".")))
+
         if not minikube_version:
             minikube_version = self.get_latest_minikube_version()
             logger.info("No minikube version is specified, latest is %s", minikube_version)
+            if k8s_version_tuple < (1, 28, 0):
+                logger.info("While latest minikube version is %s, "
+                            "the requested K8S version %s requires %s or earlier - choosing %s",
+                            minikube_version, k8s_version, MINIKUBE_MAX_VERSION_LEGACY,
+                            MINIKUBE_MAX_VERSION_LEGACY)
+                minikube_version = MINIKUBE_MAX_VERSION_LEGACY
 
         minikube_dl_file, _ = context.app.download_remote_file(logger,
                                                                f"https://github.com/kubernetes/minikube/releases"
@@ -156,12 +166,14 @@ class MinikubePlugin(KubernatorPlugin):
                                         minikube_file=str(minikube_file),
                                         profile=profile,
                                         k8s_version=k8s_version,
+                                        k8s_version_tuple=k8s_version_tuple,
                                         start_fresh=start_fresh,
                                         keep_running=keep_running,
                                         nodes=nodes,
                                         driver=driver,
                                         cpus=cpus,
                                         extra_args=extra_args or [],
+                                        extra_addons=extra_addons or [],
                                         kubeconfig=str(self.kubeconfig_dir / "config"),
                                         cmd=self.cmd,
                                         cmd_out=self.cmd_out
@@ -192,6 +204,16 @@ class MinikubePlugin(KubernatorPlugin):
                     "--wait", "apiserver",
                     "--nodes", str(minikube.nodes)]
 
+            addons = []
+            if minikube.k8s_version_tuple >= (1, 28):
+                addons += ["volumesnapshots", "csi-hostpath-driver"]
+
+            if minikube.extra_addons:
+                addons += minikube.extra_addons
+
+            if addons:
+                args += ["--addons", ",".join(addons)]
+
             if minikube.driver == "docker":
                 args.extend(["--cpus", str(minikube.cpus)])
 
@@ -202,6 +224,24 @@ class MinikubePlugin(KubernatorPlugin):
         logger.info("Updating minikube profile %r context", minikube.profile)
         self.cmd("update-context")
 
+        if minikube.k8s_version_tuple >= (1, 28):
+            logger.info("Disabling old storage addons")
+            self.cmd("addons", "disable", "storage-provisioner")
+            self.cmd("addons", "disable", "default-storageclass")
+
+        logger.info("Running initialization scripts for profile %r", minikube.profile)
+        self.context.app.register_plugin("kubectl", version=minikube.k8s_version)
+        if minikube.k8s_version_tuple >= (1, 28):
+            storage_class = self.context.kubectl.get("storageclass", "csi-hostpath-sc")
+            self.context.kubectl.run("delete", "storageclass", "csi-hostpath-sc")
+            storage_class["metadata"]["annotations"]["storageclass.kubernetes.io/is-default-class"] = "true"
+            storage_class["volumeBindingMode"] = "WaitForFirstConsumer"
+
+            def write_stdin():
+                return json.dumps(storage_class)
+
+            self.context.kubectl.run("create", "-f", "-", stdin=write_stdin)
+
     def minikube_stop(self):
         minikube = self.context.minikube
         if self.minikube_is_running():

{kubernator-1.0.21.dev20250528230808 → kubernator-1.0.23}/kubernator/proc.py

@@ -108,7 +108,7 @@ class ProcessRunner:
             raise RuntimeError("not available")
         return self._proc.stdin
 
-    def wait(self, fail=True, timeout=None, _out_func=None):
+    def wait(self, fail=True, timeout=None, _out_func=None, _stderr_func=None):
         with Timeout(timeout, TimeoutExpired):
             retcode = self._proc.wait()
             if self._stdin_writer:
@@ -119,9 +119,12 @@ class ProcessRunner:
                 self._stderr_reader.join()
         if fail and retcode:
             output = None
+            stderr = None
             if _out_func:
                 output = _out_func()
-            raise CalledProcessError(retcode, self._safe_args, output=output)
+            if _stderr_func:
+                stderr = _stderr_func()
+            raise CalledProcessError(retcode, self._safe_args, output=output, stderr=stderr)
         return retcode
 
     def terminate(self):
@@ -134,6 +137,25 @@ class ProcessRunner:
 run = ProcessRunner
 
 
+def run_pass_through_capturing(args, stdout_logger, stderr_logger, stdin=DEVNULL, *, safe_args=None,
+                               universal_newlines=True, **kwargs):
+    out = StringIO(trimmed=False) if universal_newlines else BytesIO()
+    err = StringIO(trimmed=False) if universal_newlines else BytesIO()
+
+    def write_out(data):
+        out.write(data)
+        stdout_logger(data)
+
+    def write_err(data):
+        err.write(data)
+        stderr_logger(data)
+
+    proc = run(args, write_out, write_err, stdin, safe_args=safe_args, universal_newlines=universal_newlines,
+               **kwargs)
+    proc.wait(_out_func=lambda: out.getvalue(), _stderr_func=lambda: err.getvalue())
+    return out.getvalue(), err.getvalue()
+
+
 def run_capturing_out(args, stderr_logger, stdin=DEVNULL, *, safe_args=None, universal_newlines=True, **kwargs):
     out = StringIO(trimmed=False) if universal_newlines else BytesIO()
     proc = run(args, out.write, stderr_logger, stdin, safe_args=safe_args, universal_newlines=universal_newlines,

{kubernator-1.0.21.dev20250528230808 → kubernator-1.0.23}/kubernator.egg-info/PKG-INFO

@@ -1,23 +1,23 @@
 Metadata-Version: 2.4
 Name: kubernator
-Version: 1.0.21.dev20250528230808
+Version: 1.0.23
 Summary: Kubernator is the a pluggable framework for K8S provisioning
 Home-page: https://github.com/karellen/kubernator
 Author: Express Systems USA, Inc.
 Author-email: 
 Maintainer: Karellen, Inc., Arcadiy Ivanov
 Maintainer-email: supervisor@karellen.co,arcadiy@karellen.co
-License: Apache License, Version 2.0
+License: Apache-2.0
 Project-URL: Bug Tracker, https://github.com/karellen/kubernator/issues
 Project-URL: Documentation, https://github.com/karellen/kubernator/
 Project-URL: Source Code, https://github.com/karellen/kubernator/
 Keywords: kubernetes k8s kube top provisioning kOps terraform tf AWS
-Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Operating System :: MacOS :: MacOS X
 Classifier: Operating System :: POSIX
 Classifier: Operating System :: POSIX :: Linux
@@ -45,7 +45,7 @@ Requires-Dist: kubernetes~=32.0
 Requires-Dist: openapi-schema-validator~=0.1
 Requires-Dist: openapi-spec-validator~=0.3
 Requires-Dist: platformdirs~=4.2
-Requires-Dist: requests<=2.31.0
+Requires-Dist: requests>=2.31.0
 Dynamic: author
 Dynamic: classifier
 Dynamic: description

{kubernator-1.0.21.dev20250528230808 → kubernator-1.0.23}/kubernator.egg-info/SOURCES.txt

@@ -20,6 +20,7 @@ kubernator.egg-info/zip-safe
 kubernator/plugins/__init__.py
 kubernator/plugins/awscli.py
 kubernator/plugins/eks.py
+kubernator/plugins/gke.py
 kubernator/plugins/helm.py
 kubernator/plugins/istio.py
 kubernator/plugins/k8s.py

{kubernator-1.0.21.dev20250528230808 → kubernator-1.0.23}/kubernator.egg-info/requires.txt

@@ -11,4 +11,4 @@ kubernetes~=32.0
 openapi-schema-validator~=0.1
 openapi-spec-validator~=0.3
 platformdirs~=4.2
-requests<=2.31.0
+requests>=2.31.0

{kubernator-1.0.21.dev20250528230808 → kubernator-1.0.23}/setup.py

@@ -21,17 +21,17 @@ class install(_install):
 if __name__ == '__main__':
     setup(
         name = 'kubernator',
-        version = '1.0.21.dev20250528230808',
+        version = '1.0.23',
         description = 'Kubernator is the a pluggable framework for K8S provisioning',
         long_description = '# Kubernator\n\nKubernator™ (Ktor™) is an integrated solution for the Kubernetes state management. It operates on directories,\nprocessing their content via a collection of plugins, generating Kubernetes resources in the process, validating them,\ntransforming them and then applying against the Kubernetes cluster.\n\n[![Gitter](https://img.shields.io/gitter/room/karellen/lobby?logo=gitter)](https://gitter.im/karellen/Lobby)\n[![Build Status](https://img.shields.io/github/actions/workflow/status/karellen/kubernator/kubernator.yml?branch=master)](https://github.com/karellen/kubernator/actions/workflows/kubernator.yml)\n[![Coverage Status](https://img.shields.io/coveralls/github/karellen/kubernator/master?logo=coveralls)](https://coveralls.io/r/karellen/kubernator?branch=master)\n\n[![Kubernator Version](https://img.shields.io/pypi/v/kubernator?logo=pypi)](https://pypi.org/project/kubernator/)\n[![Kubernator Python Versions](https://img.shields.io/pypi/pyversions/kubernator?logo=pypi)](https://pypi.org/project/kubernator/)\n[![Kubernator Downloads Per Day](https://img.shields.io/pypi/dd/kubernator?logo=pypi)](https://pypi.org/project/kubernator/)\n[![Kubernator Downloads Per Week](https://img.shields.io/pypi/dw/kubernator?logo=pypi)](https://pypi.org/project/kubernator/)\n[![Kubernator Downloads Per Month](https://img.shields.io/pypi/dm/kubernator?logo=pypi)](https://pypi.org/project/kubernator/)\n\n## Notices\n\n### Beta Software\n\nWhile fully functional in the current state and used in production, this software is in **BETA**. A lot of things\nare expected to change rapidly, including main APIs, initialization procedures and some core features. Documentation at\nthis stage is basically non-existent.\n\n### License\n\nThe product is licensed under the Apache License, Version 2.0. Please see LICENSE for further details.\n\n### Warranties and Liability\n\nKubernator and its plugins are provided on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either\nexpress or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT,\nMERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of\nusing or redistributing Kubernator and assume any risks associated with doing so.\n\n### Trademarks\n\n"Kubernator" and "Ktor" are trademarks or registered trademarks of Express Systems USA, Inc and Karellen, Inc. All other\ntrademarks are property of their respective owners.\n\n## Problem Statement\n\n## Solution\n\n## Using Kubernator with Docker\n\nA simple example is as follows:\n```\n$ docker run --mount type=bind,source="$(pwd)",target=/root,readonly -t ghcr.io/karellen/kubernator:latest\n```\n\n## Using Kubernator on MacOS\n\n```\n$ brew install python3.11\n$ pip3.11 install \'kubernator~=1.0.9\'\n$ kubernator --version\n```\n\nPlease note, that some plugins (e.g. `awscli`, `eks`) may require additional volume mounts or environmental\nvariables to be passed for credentials and other external configuration.\n\n## Mode of Operation\n\nKubernator is a command line utility. Upon startup and processing of the command line arguments and initializing\nlogging, Kubernator initializes plugins. Current plugins include:\n\n0. Kubernator App\n1. Terraform\n2. kOps\n3. Kubernetes\n4. Helm\n5. Template\n\nThe order of initialization matters as it\'s the order the plugin handlers are executed!\n\nThe entire application operates in the following stages by invoking each plugin\'s stage handler in sequence:\n\n1. Plugin Init Stage\n2. Pre-start script (if specified)\n3. Plugin Start Stage\n4. For each directory in the pipeline:\n    1. Plugin Before Directory Stage\n    2. If `.kubernator.py` is present in the directory:\n        1. Plugin Before Script Stage\n        2. `.kubernator.py` script\n        3. Plugin After Script Stage\n    3. Plugin After Directory Stage\n5. Plugin End Stage\n\nEach plugin individually plays a specific role and performs a specific function which will be described in a later\nsection.\n\n## State/Context\n\nThere is a global state that is carried through as the application is running. It is a hierarchy of objects (`context`)\nthat follows the parent-child relationship as the application traverses the directory structure. For example, given the\ndirectory structure `/a/b`, `/a/c`, and `/a/c/d` any value of the context set or modified in context scoped to\ndirectory `/a` is visible in directories `/a/b`, `/a/c` and `/a/c/d`, while the same modified or set in `/a/b` is only\nvisible there, while one in `/a/c` is visible in `/a/c` and in `/a/c/d` but not `/a` or `/a/b`.\n\nAdditionally, there is a `context.globals` which is the top-most context that is available in all stages that are not\nassociated with the directory structure.\n\nNote, that in cases where the directory structure traversal moves to remote directories (that are actualized by local\ntemporary directories), such remote directory structure enters the context hierarchy as a child of the directory in\nwhich remote was registered.\n\nAlso note, that context carries not just data by references to essential functions.\n\nIn pre-start and `.kubernator.py` scripts the context is fully available as a global variable `ktor`.\n\n### Plugins\n\n#### Kubernator App Plugin\n\nThe role of the Kubernator App Plugin is to traverse the directory structure, expose essential functions through context\nand to run Kubernator scripts.\n\nIn the *After Directory Stage* Kubernator app scans the directories immediately available in the current, sorts them in\nthe alphabetic order, excludes those matching any of the patterns in `context.app.excludes` and then queues up the\nremaining directories in the order the match the patterns in `context.app.includes`.\n\nThus, for a directory content `/a/foo`, `/a/bal`, `/a/bar`, `/a/baz`, excludes `f*`, and includes `baz` and `*`, the\nresulting queue of directories to traverse will be `/a/baz`, `/a/bal`, `/a/bar`.\n\nNotice, that user can further interfere with processing order of the directory queue by asking Kubernator to walk\narbitrary paths, both local and remote.\n\n##### Context\n\n* `ktor.app.args`\n  > Namespace containing command line argument values\n* `ktor.app.walk_local(*paths: Union[Path, str, bytes])`\n  > Immediately schedules the paths to be traversed after the current directory by adding them to the queue\n  > Relative path is relative to the current directory\n* `ktor.app.walk_remote(repo, *path_prefixes: Union[Path, str, bytes])`\n  > Immediately schedules the path prefixes under the remote repo URL to be traversed after the current directory by\n  > adding them to the queue. Only Git URLs are currently supported.\n  > All absolute path prefixes are relativized based on the repository.\n* `ktor.app.repository_credentials_provider(func: Callable)`\n  > Sets a repository credentials provider function `func` that sets/overwrites credentials for URLs being specified by\n  > `walk_remote`. The callable `func` accepts a single argument containing a parsed URL in a form of tuple. The `func`\n  > is expected to return a tuple of three elements representing URL schema, username and password. If the value should\n  > not be changed it should be None. To convert from `git://repo.com/hello` to HTTPS authentication one should write\n  > a function returning `("https", "username", "password")`. The best utility is achieved by logic that allows running\n  > the plan both in CI and local environments using different authentication mechanics in different environments.\n\n#### Terraform\n\nThis is exclusively designed to pull the configuration options out of Terraform and to allow scripts and plugins to\nutilize that data.\n\n##### Context\n\n* `ktor.tf`\n  > A dictionary containing the values from Terraform output\n\n#### Kops\n\n##### Context\n\n#### Kubernetes\n\n##### Context\n\n#### Helm\n\n##### Context\n\n#### Templates\n\n##### Context\n\n## Examples\n\n### Adding Remote Directory\n\n```python\nktor.app.repository_credentials_provider(lambda r: ("ssh", "git", None))\nktor.app.walk_remote("git://repo.example.com/org/project?ref=dev", "/project")\n```\n\n### Adding Local Directory\n\n```python\nktor.app.walk_local("/home/username/local-dir")\n```\n\n### Using Transformers\n\n```python\ndef remove_replicas(resources, r: "K8SResource"):\n    if (r.group == "apps" and r.kind in ("StatefulSet", "Deployment")\n            and "replicas" in r.manifest["spec"]):\n        logger.warning("Resource %s in %s contains `replica` specification that will be removed. Use HPA!!!",\n                       r, r.source)\n        del r.manifest["spec"]["replicas"]\n\n\nktor.k8s.add_transformer(remove_replicas)\n```\n',
         long_description_content_type = 'text/markdown',
         classifiers = [
-            'License :: OSI Approved :: Apache Software License',
             'Programming Language :: Python :: 3.9',
             'Programming Language :: Python :: 3.10',
             'Programming Language :: Python :: 3.11',
             'Programming Language :: Python :: 3.12',
             'Programming Language :: Python :: 3.13',
+            'Programming Language :: Python :: 3.14',
             'Operating System :: MacOS :: MacOS X',
             'Operating System :: POSIX',
             'Operating System :: POSIX :: Linux',
@@ -52,7 +52,7 @@ if __name__ == '__main__':
         maintainer = 'Karellen, Inc., Arcadiy Ivanov',
         maintainer_email = 'supervisor@karellen.co,arcadiy@karellen.co',
 
-        license = 'Apache License, Version 2.0',
+        license = 'Apache-2.0',
 
         url = 'https://github.com/karellen/kubernator',
         project_urls = {
@@ -89,7 +89,7 @@ if __name__ == '__main__':
             'openapi-schema-validator~=0.1',
             'openapi-spec-validator~=0.3',
             'platformdirs~=4.2',
-            'requests<=2.31.0'
+            'requests>=2.31.0'
         ],
         dependency_links = [],
         zip_safe = True,