kube-envx 0.2.2a0__tar.gz

kube_envx-0.2.2a0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 ohmycoffe
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

kube_envx-0.2.2a0/PKG-INFO

@@ -0,0 +1,94 @@
+Metadata-Version: 2.4
+Name: kube-envx
+Version: 0.2.2a0
+Summary: Extract environment variables from Kubernetes resources in dotenv format
+License-File: LICENSE
+Author: ohmycoffe
+Author-email: ohmycoffe1@gmail.com
+Requires-Python: >=3.10
+Classifier: Programming Language :: Python :: 3
+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
+Requires-Dist: questionary (>=2.1.1,<3.0.0)
+Requires-Dist: typer (>=0.16.0,<0.17.0)
+Description-Content-Type: text/markdown
+
+# kube-kenvx
+
+[![Python](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+Extract and export environment variables from Kubernetes Deployments and Argo WorkflowTemplates — interactively or scripted.
+
+![demo](https://github.com/user-attachments/assets/4c492cd0-87ab-4c97-90b5-fa5e3a43db82)
+
+## Installation
+
+**pipx**:
+
+```bash
+pipx install git+https://github.com/ohmycoffe/kube-envx.git
+```
+
+**Poetry** (development):
+
+```bash
+poetry install
+```
+
+## Usage
+
+Run without arguments for fully interactive mode:
+
+```bash
+kenvx
+```
+
+Or pass options directly to skip individual prompts:
+
+```bash
+kenvx --kind deployment --namespace my-namespace --name my-service
+```
+
+### Options
+
+| Option | Default | Description |
+|---|---|---|
+| `--kind` | — | `deployment` or `workflowtemplate`. Prompted if omitted. |
+| `--namespace` | — | Kubernetes namespace. Prompted if omitted. |
+| `--name` | — | Resource name. Prompted if omitted. |
+| `--output` | `env` | Output format: `env` or `json`. |
+| `-v` / `-vv` | — | Verbosity: info / debug. |
+
+### Environment variables
+
+| Variable | Description |
+|---|---|
+| `ENVX_NAMESPACE` | Default namespace, overridden by `--namespace`. |
+
+## Examples
+
+Export env vars for a deployment to a dotenv file:
+
+```bash
+kenvx --kind deployment --name my-service --namespace prod > .env
+```
+
+Extract WorkflowTemplate env vars as JSON:
+
+```bash
+kenvx --kind workflowtemplate --name my-workflow --namespace argo --output json
+```
+
+## Requirements
+
+- Python 3.10+
+- [`kubectl`](https://kubernetes.io/docs/tasks/tools/) configured with cluster access
+
+## License
+
+MIT — see [LICENSE](LICENSE).
+

kube_envx-0.2.2a0/README.md

@@ -0,0 +1,75 @@
+# kube-kenvx
+
+[![Python](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+Extract and export environment variables from Kubernetes Deployments and Argo WorkflowTemplates — interactively or scripted.
+
+![demo](https://github.com/user-attachments/assets/4c492cd0-87ab-4c97-90b5-fa5e3a43db82)
+
+## Installation
+
+**pipx**:
+
+```bash
+pipx install git+https://github.com/ohmycoffe/kube-envx.git
+```
+
+**Poetry** (development):
+
+```bash
+poetry install
+```
+
+## Usage
+
+Run without arguments for fully interactive mode:
+
+```bash
+kenvx
+```
+
+Or pass options directly to skip individual prompts:
+
+```bash
+kenvx --kind deployment --namespace my-namespace --name my-service
+```
+
+### Options
+
+| Option | Default | Description |
+|---|---|---|
+| `--kind` | — | `deployment` or `workflowtemplate`. Prompted if omitted. |
+| `--namespace` | — | Kubernetes namespace. Prompted if omitted. |
+| `--name` | — | Resource name. Prompted if omitted. |
+| `--output` | `env` | Output format: `env` or `json`. |
+| `-v` / `-vv` | — | Verbosity: info / debug. |
+
+### Environment variables
+
+| Variable | Description |
+|---|---|
+| `ENVX_NAMESPACE` | Default namespace, overridden by `--namespace`. |
+
+## Examples
+
+Export env vars for a deployment to a dotenv file:
+
+```bash
+kenvx --kind deployment --name my-service --namespace prod > .env
+```
+
+Extract WorkflowTemplate env vars as JSON:
+
+```bash
+kenvx --kind workflowtemplate --name my-workflow --namespace argo --output json
+```
+
+## Requirements
+
+- Python 3.10+
+- [`kubectl`](https://kubernetes.io/docs/tasks/tools/) configured with cluster access
+
+## License
+
+MIT — see [LICENSE](LICENSE).

kube_envx-0.2.2a0/pyproject.toml

@@ -0,0 +1,37 @@
+[project]
+name = "kube-envx"
+version = "0.2.2a0"
+description = "Extract environment variables from Kubernetes resources in dotenv format"
+authors = [
+    {name = "ohmycoffe",email = "ohmycoffe1@gmail.com"}
+]
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "typer (>=0.16.0,<0.17.0)",
+    "questionary (>=2.1.1,<3.0.0)",
+]
+
+[project.scripts]
+kenvx = "kenvx.__main__:app"
+envx = "kenvx.__main__:deprecated_entry"
+
+[tool.poetry]
+packages = [
+    { from = "src", include = "kenvx" },
+]
+
+[tool.poetry.group.dev.dependencies]
+ruff = "^0.12.8"
+pytest = "^9.0.3"
+
+[tool.ruff]
+line-length = 88
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "B", "UP"]
+ignore = ["E501"]
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"

kube_envx-0.2.2a0/src/kenvx/__main__.py

@@ -0,0 +1,18 @@
+import logging
+
+from kenvx.cli.main import app
+from kenvx.console import console
+from kenvx.style import COLOR_WARNING
+
+logging.basicConfig()
+
+
+def deprecated_entry() -> None:
+    console.print(
+        f"[bold {COLOR_WARNING}]Warning:[/] 'envx' has been deprecated, use 'kenvx' instead."
+    )
+    app()
+
+
+if __name__ == "__main__":
+    app()

kube_envx-0.2.2a0/src/kenvx/cli/main.py

@@ -0,0 +1,160 @@
+from __future__ import annotations
+
+import enum
+import json
+import subprocess
+from typing import Annotated
+
+import questionary
+import typer
+
+from kenvx.console import console, print_error
+from kenvx.kube import (
+    get_available_deployments,
+    get_available_namespaces,
+    get_available_workflowtemplates,
+    get_deployment_envs,
+    get_workflowtemplate_envs,
+)
+from kenvx.style import COLOR_MUTED, STYLE
+from kenvx.utils import export_as_dotenv, resolve_namespace, setup_logging
+
+
+class ResourceKind(str, enum.Enum):
+    DEPLOYMENT = "deployment"
+    WORKFLOWTEMPLATE = "workflowtemplate"
+
+
+class ExportFormat(str, enum.Enum):
+    ENV = "env"
+    JSON = "json"
+
+
+app = typer.Typer()
+
+
+def select_resource_kind() -> ResourceKind:
+    selected = questionary.select(
+        "Select a kind:",
+        choices=[
+            questionary.Choice(
+                title="Deployment",
+                value=ResourceKind.DEPLOYMENT,
+                description="(Kubernetes Deployment)",
+            ),
+            questionary.Choice(
+                title="WorkflowTemplate",
+                value=ResourceKind.WORKFLOWTEMPLATE,
+                description="(Argo WorkflowTemplate)",
+            ),
+        ],
+        use_jk_keys=False,
+        style=STYLE,
+    ).ask()
+    if not selected:
+        raise typer.Exit(code=0)
+    return ResourceKind(selected)
+
+
+@app.callback(invoke_without_command=True)
+def get(
+    kind: Annotated[
+        ResourceKind | None,
+        typer.Option(
+            help="Kind of resource to get parameters for. If not provided, you will be prompted to select one.",
+        ),
+    ] = None,
+    namespace: Annotated[
+        str | None,
+        typer.Option(
+            envvar="KENVX_NAMESPACE",
+            help="Kubernetes namespace. If not provided, you will be prompted to select one.",
+        ),
+    ] = None,
+    name: Annotated[
+        str | None,
+        typer.Option(
+            help="Name of the resource. If not provided, you will be prompted to select one.",
+        ),
+    ] = None,
+    output: ExportFormat = ExportFormat.ENV,
+    verbose: Annotated[
+        int,
+        typer.Option(
+            "--verbose", "-v", count=True, help="Verbose output. Use -vv for debug."
+        ),
+    ] = 0,
+):
+    """
+    Get environment variables for a Kubernetes deployment or Argo WorkflowTemplate.
+    """
+    setup_logging(verbose)
+
+    if kind is None:
+        kind = select_resource_kind()
+
+    try:
+        with console.status(f"[italic {COLOR_MUTED}]Fetching available namespaces…[/]"):
+            namespaces = get_available_namespaces()
+    except subprocess.CalledProcessError as e:
+        print_error(e, "Failed to fetch available namespaces")
+        raise typer.Exit(code=1) from None
+
+    namespace = resolve_namespace(namespace, available_namespaces=namespaces)
+
+    try:
+        with console.status(
+            f"[italic {COLOR_MUTED}]Fetching available {kind.value}s in {namespace}…[/]"
+        ):
+            if kind == ResourceKind.DEPLOYMENT:
+                resources = get_available_deployments(namespace=namespace)
+            else:
+                resources = get_available_workflowtemplates(namespace=namespace)
+    except subprocess.CalledProcessError as e:
+        print_error(
+            e, f"Failed to fetch available {kind.value}s in namespace '{namespace}'"
+        )
+        raise typer.Exit(code=1) from None
+    if not resources:
+        console.print(f"[red]Error: no {kind.value}s found in namespace '{namespace}'")
+        raise typer.Exit(code=1)
+
+    if not name:
+        name = questionary.select(
+            f"Select a {kind.value}:",
+            choices=resources,
+            use_search_filter=True,
+            use_jk_keys=False,
+            style=STYLE,
+        ).ask()
+        if not name:
+            raise typer.Exit(code=0)
+
+    if name not in resources:
+        console.print(
+            f"[red]Error:[/red] {kind.value} '{name}' not found in namespace '{namespace}'."
+        )
+        raise typer.Exit(code=1)
+
+    try:
+        with console.status(
+            f"[italic {COLOR_MUTED}]Fetching environment variables…[/]"
+        ):
+            if kind == ResourceKind.DEPLOYMENT:
+                vals = get_deployment_envs(namespace=namespace, name=name)
+            else:
+                vals = get_workflowtemplate_envs(namespace=namespace, name=name)
+    except subprocess.CalledProcessError as e:
+        print_error(e, f"Failed to fetch environment variables for '{name}'")
+        raise typer.Exit(code=1) from None
+
+    if output == ExportFormat.JSON:
+        formatted = json.dumps(vals, sort_keys=True)
+    elif output == ExportFormat.ENV:
+        formatted = export_as_dotenv(vals=vals, name=name)
+    print(formatted)
+    raise typer.Exit(code=0)
+
+
+if __name__ == "__main__":
+    app()

kube_envx-0.2.2a0/src/kenvx/console.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+import logging
+import subprocess
+
+from rich.console import Console
+from rich.panel import Panel
+
+from kenvx.style import COLOR_ERROR
+
+console = Console(stderr=True)
+
+logger = logging.getLogger(__name__)
+
+
+def print_error(e: subprocess.CalledProcessError, msg: str) -> None:
+    logger.debug("kubectl error", exc_info=e, stack_info=True)
+    stderr = (e.stderr or "no output").strip()
+    stdout = (e.stdout or "no output").strip()
+    cmd = " ".join(e.cmd)
+    content = "\n".join(
+        [
+            "[dim]stderr:[/dim]",
+            f"[{COLOR_ERROR}]{stderr}[/]",
+            "",
+            "[dim]stdout:[/dim]",
+            stdout,
+            "",
+            f"[dim]command:[/dim] {cmd}",
+            f"[dim]exit code:[/dim] {e.returncode}",
+        ]
+    )
+    console.print(
+        Panel(
+            content,
+            title=f"[bold {COLOR_ERROR}]{msg}[/]",
+            border_style=COLOR_ERROR,
+            expand=False,
+        )
+    )

kube_envx-0.2.2a0/src/kenvx/kube.py

@@ -0,0 +1,168 @@
+from __future__ import annotations
+
+import json
+import logging
+import re
+import subprocess
+from collections.abc import Callable
+from functools import lru_cache
+from typing import Any
+
+from kenvx.utils import decode
+
+logger = logging.getLogger(__name__)
+
+
+def call_subprocess(cmd: list[str]) -> str:
+    logger.debug("%s", " ".join(cmd))
+    result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+    return result.stdout
+
+
+def get_available_namespaces() -> list[str]:
+    cmd = ["kubectl", "get", "namespaces", "-o", "json"]
+    result = call_subprocess(cmd)
+    data = json.loads(result)
+    return [el["metadata"]["name"] for el in data["items"]]
+
+
+@lru_cache
+def get_secret(namespace: str, name: str) -> dict[str, Any]:
+    cmd = ["kubectl", "get", "secret", name, "-n", namespace, "-o", "json"]
+    result = call_subprocess(cmd)
+    secret = json.loads(result)
+    return secret
+
+
+@lru_cache
+def get_configmap(namespace: str, name: str) -> dict[str, Any]:
+    cmd = ["kubectl", "get", "configmap", name, "-n", namespace, "-o", "json"]
+    result = call_subprocess(cmd)
+    configmap = json.loads(result)
+    return configmap
+
+
+def _clean_key(key: str) -> str:
+    def strip_argo_inputs_param(key: str) -> str:
+        match = re.match(r"^\{\{inputs\.parameters\.(?P<param_name>\w+)\}\}$", key)
+        return match.group("param_name") if match else key
+
+    cleanups: list[Callable[[str], str]] = [
+        strip_argo_inputs_param,
+    ]
+
+    for cleanup in cleanups:
+        key = cleanup(key)
+    return key
+
+
+def get_available_deployments(namespace: str) -> list[str]:
+    cmd = ["kubectl", "get", "deployment", "-n", namespace, "-o", "json"]
+    result = call_subprocess(cmd)
+    data = json.loads(result)
+    return [el["metadata"]["name"] for el in data["items"]]
+
+
+def get_deployment_envs(namespace: str, name: str) -> dict[str, str]:
+    cmd = ["kubectl", "get", "deployment", name, "-n", namespace, "-o", "json"]
+    result = call_subprocess(cmd)
+    deployment = json.loads(result)
+    containers = deployment["spec"]["template"]["spec"]["containers"]
+    if len(containers) != 1:
+        raise ValueError(f"Expected 1 container, got {len(containers)}")
+    return extract_envs_from_container(namespace=namespace, container=containers[0])
+
+
+def get_available_workflowtemplates(namespace: str) -> list[str]:
+    cmd = ["kubectl", "get", "workflowtemplate", "-n", namespace, "-o", "json"]
+    result = call_subprocess(cmd)
+    data = json.loads(result)
+    return [el["metadata"]["name"] for el in data["items"]]
+
+
+def get_workflowtemplate_envs(namespace: str, name: str) -> dict[str, str]:
+    cmd = ["kubectl", "get", "workflowtemplate", name, "-n", namespace, "-o", "json"]
+    result = call_subprocess(cmd)
+    workflow = json.loads(result)
+    envs = {}
+    for template in workflow["spec"]["templates"]:
+        if "container" not in template:
+            continue
+        fallback_keys = {
+            p["name"]: p["default"]
+            for p in template.get("inputs", {}).get("parameters", [])
+            if "default" in p
+        }
+        envs.update(
+            extract_envs_from_container(
+                namespace, template["container"], fallback_keys=fallback_keys
+            )
+        )
+    return envs
+
+
+def extract_envs_from_container(
+    namespace: str,
+    container: dict[str, Any],
+    fallback_keys: dict[str, str] | None = None,
+) -> dict[str, str]:
+    if fallback_keys is None:
+        fallback_keys = {}
+    result = {}
+    if "envFrom" in container:
+        for env_from in container["envFrom"]:
+            if "configMapRef" in env_from:
+                configmap = get_configmap(namespace, env_from["configMapRef"]["name"])
+                result.update(configmap["data"])
+            elif "secretRef" in env_from:
+                secret_name = env_from["secretRef"]["name"]
+                secret = get_secret(namespace, secret_name)
+                encoded = {k: decode(v) for k, v in secret["data"].items()}
+                result.update(encoded)
+            else:
+                raise ValueError(f"Unknown envFrom format: {env_from}")
+
+    if "env" in container:
+        for env in container["env"]:
+            name = env["name"]
+            if "value" in env:
+                value = env["value"]
+                result[name] = value
+            elif "valueFrom" in env:
+                value_from = env["valueFrom"]
+                if "configMapKeyRef" in value_from:
+                    configmap = get_configmap(
+                        namespace, value_from["configMapKeyRef"]["name"]
+                    )
+                    key = value_from["configMapKeyRef"]["key"]
+                    if key not in configmap["data"]:
+                        key = fallback_keys.get(_clean_key(key), key)
+                    if key not in configmap["data"]:
+                        logger.warning(
+                            f"{name} won't be set: key {key} not found in ConfigMap {value_from['configMapKeyRef']['name']}"
+                        )
+                        value = ""
+                    else:
+                        value = configmap["data"][key]
+                    result[name] = value
+                elif "secretKeyRef" in value_from:
+                    secret_name = value_from["secretKeyRef"]["name"]
+                    encoded = get_secret(namespace, secret_name)
+                    key = value_from["secretKeyRef"]["key"]
+                    if key not in encoded["data"]:
+                        key = fallback_keys.get(_clean_key(key), key)
+                    if key not in encoded["data"]:
+                        logger.warning(
+                            f"{name} won't be set: key {key} not found in Secret {secret_name}"
+                        )
+                        value = ""
+                    else:
+                        value = decode(encoded["data"][key])
+                    result[name] = value
+                else:
+                    logger.warning(
+                        f"Unknown valueFrom format: {value_from} for {name} ({env})"
+                    )
+            else:
+                logger.warning(f"Unknown env format: {env}")
+    return result

kube_envx-0.2.2a0/src/kenvx/style.py

@@ -0,0 +1,27 @@
+from questionary import Style
+
+# fmt: off
+COLOR_ACCENT  = "#e5c07b"  # yellow     — draws attention (qmark)
+COLOR_SUCCESS = "#98c379"  # green      — confirmed / selected
+COLOR_ACTIVE  = "#61afef"  # blue       — navigation / pointer
+COLOR_WARNING  = "#d19a66"  # orange     — warnings / cautions
+COLOR_ERROR   = "#e06c75"  # red        — errors / failures
+COLOR_MUTED   = "#5c6370"  # gray       — secondary elements
+COLOR_SUBTLE  = "#4b5263"  # dark gray  — near-invisible hints
+
+# fmt: off
+STYLE = Style(
+    [
+        ("qmark",       f"fg:{COLOR_ACCENT} bold"),
+        ("question",    "bold"),
+        ("answer",      f"fg:{COLOR_SUCCESS} bold"),
+        ("pointer",     f"fg:{COLOR_ACTIVE} bold"),
+        ("highlighted", f"fg:{COLOR_ACTIVE} bold"),
+        ("selected",    f"fg:{COLOR_SUCCESS}"),
+        ("separator",   f"fg:{COLOR_MUTED}"),
+        ("instruction", f"fg:{COLOR_SUBTLE} italic"),
+        ("text",        ""),
+        ("disabled",    f"fg:{COLOR_SUBTLE} italic"),
+    ]
+)
+# fmt: on

kube_envx-0.2.2a0/src/kenvx/utils.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+import base64
+import datetime
+import logging
+
+import questionary
+import typer
+
+from kenvx.console import console
+from kenvx.style import STYLE
+
+
+def setup_logging(verbose: int) -> None:
+    levels = [logging.WARNING, logging.INFO, logging.DEBUG]
+    level = levels[min(verbose, len(levels) - 1)]
+    logging.getLogger("kenvx").setLevel(level)
+
+
+def decode(val: str) -> str:
+    decoded_bytes = base64.b64decode(val)
+    return decoded_bytes.decode("utf-8")
+
+
+def export_as_dotenv(vals: dict[str, str], name: str | None = None) -> str:
+    sorted_list = sorted(vals.items(), key=lambda x: x[0])
+    res = []
+    if name:
+        now = datetime.datetime.now().isoformat(timespec="seconds")
+        res.append(f"# {name} @ {now}")
+    for key, value in sorted_list:
+        res.append(f"{key}={value}")
+    return "\n".join(res)
+
+
+def resolve_namespace(value: str | None, available_namespaces: list[str]) -> str:
+    if value:
+        if value not in available_namespaces:
+            console.print(f"[red]Error:[/red] namespace '{value}' not found.")
+            raise typer.Exit(code=1)
+        return value
+    selected = questionary.select(
+        "Select a namespace:",
+        choices=available_namespaces,
+        use_search_filter=True,
+        use_jk_keys=False,
+        style=STYLE,
+    ).ask()
+    if not selected:
+        raise typer.Exit(code=0)
+    return selected