chartreuse 7.0.0.dev0__tar.gz → 7.0.1__tar.gz

{chartreuse-7.0.0.dev0/src/chartreuse.egg-info → chartreuse-7.0.1}/PKG-INFO

@@ -1,18 +1,21 @@
 Metadata-Version: 2.4
 Name: chartreuse
-Version: 7.0.0.dev0
+Version: 7.0.1
 Summary: Helper for Alembic migrations within Kubernetes.
 Author-email: wiremind <dev@wiremind.io>
 License-Expression: LGPL-3.0-or-later
 Project-URL: github, https://github.com/wiremind/chartreuse
-Requires-Python: >=3.11.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.13.0
 Description-Content-Type: text/markdown
 License-File: LICENCE.md
 Requires-Dist: alembic
-Requires-Dist: psycopg[binary]
+Requires-Dist: kubernetes
+Requires-Dist: psycopg2
 Requires-Dist: pydantic>=2.0.0
 Requires-Dist: PyYAML
-Requires-Dist: wiremind-kubernetes~=7.0
 Provides-Extra: test
 Requires-Dist: mock; extra == "test"
 Requires-Dist: pytest; extra == "test"
@@ -40,7 +43,7 @@ Chartreuse leverages [Helm Hooks](https://helm.sh/docs/topics/charts_hooks/), th
 
 ### Requirements
 
-- Python >= 3.7
+- Python >= 3.13
 - Using Helm to deploy you application
 - This Python package requires the `expecteddeploymentscales.wiremind.io` Kubernetes `Custom Resource Definition`:
 

{chartreuse-7.0.0.dev0 → chartreuse-7.0.1}/README.md

@@ -11,7 +11,7 @@ Chartreuse leverages [Helm Hooks](https://helm.sh/docs/topics/charts_hooks/), th
 
 ### Requirements
 
-- Python >= 3.7
+- Python >= 3.13
 - Using Helm to deploy you application
 - This Python package requires the `expecteddeploymentscales.wiremind.io` Kubernetes `Custom Resource Definition`:
 

chartreuse-7.0.1/VERSION

@@ -0,0 +1 @@
+7.0.1

{chartreuse-7.0.0.dev0 → chartreuse-7.0.1}/pyproject.toml

@@ -6,15 +6,20 @@ readme = "README.md"
 authors = [{ name = "wiremind", email = "dev@wiremind.io" }]
 license="LGPL-3.0-or-later"
 urls = { github = "https://github.com/wiremind/chartreuse"}
-scripts = {chartreuse-upgrade = "chartreuse.chartreuse_upgrade:main"}
-requires-python = ">=3.11.0"
+scripts = {chartreuse-upgrade = "chartreuse.chartreuse_upgrade:main", chartreuse-restore = "chartreuse.chartreuse_restore:main"}
+requires-python = ">=3.13.0"
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
+]
 
 dependencies = [
   "alembic",
-  "psycopg[binary]",
+  "kubernetes",
+  "psycopg2",
   "pydantic>=2.0.0",
   "PyYAML",
-  "wiremind-kubernetes~=7.0",
 ]
 
 [build-system]
@@ -50,7 +55,7 @@ dev = [
 
 [tool.ruff]
 line-length = 120
-target-version = "py311"
+target-version = "py313"
 
 [tool.ruff.lint]
 select = [

{chartreuse-7.0.0.dev0 → chartreuse-7.0.1}/src/chartreuse/chartreuse.py

@@ -1,8 +1,7 @@
 import logging
 
-import wiremind_kubernetes.kubernetes_helper
-
 from .config_loader import DatabaseConfig
+from .kubernetes_helper import KubernetesDeploymentManager
 from .utils import AlembicMigrationHelper
 
 logger = logging.getLogger(__name__)
@@ -23,7 +22,7 @@ class Chartreuse:
         self,
         databases_config: dict[str, DatabaseConfig],
         release_name: str,
-        kubernetes_helper: wiremind_kubernetes.kubernetes_helper.KubernetesDeploymentManager | None = None,
+        kubernetes_helper: KubernetesDeploymentManager | None = None,
     ):
         configure_logging()
 
@@ -56,9 +55,7 @@ class Chartreuse:
         if kubernetes_helper:
             self.kubernetes_helper = kubernetes_helper
         else:
-            self.kubernetes_helper = wiremind_kubernetes.kubernetes_helper.KubernetesDeploymentManager(
-                use_kubeconfig=None, release_name=release_name
-            )
+            self.kubernetes_helper = KubernetesDeploymentManager(use_kubeconfig=None, release_name=release_name)
 
     @property
     def is_migration_needed(self) -> bool:

chartreuse-7.0.1/src/chartreuse/chartreuse_restore.py

@@ -0,0 +1,36 @@
+import logging
+import os
+
+from .chartreuse import configure_logging
+from .chartreuse_upgrade import ensure_safe_run
+from .kubernetes_helper import KubernetesDeploymentManager
+
+logger = logging.getLogger(__name__)
+
+
+def main() -> None:
+    """
+    Restore Deployments that a pre-deployment migration (CHARTREUSE_UPGRADE_BEFORE_DEPLOYMENT)
+    stopped and that the deployment itself could not scale back up.
+
+    On that path chartreuse-upgrade intentionally skips start_pods() and relies on the
+    deployment that follows to restore replicas. That works for Deployments whose chart sets
+    spec.replicas, but HPA-managed ones omit it: they stay at 0 replicas and an HPA whose
+    target is at 0 with minReplicas >= 1 is ScalingDisabled and never scales them back up.
+
+    Runs as a post-deployment (e.g. ArgoCD PostSync) hook: the new pod template is already
+    applied, so scaling up only ever starts new-version pods. Only Deployments still carrying
+    the annotation set by stop_pods() are touched. If this program fails, the deployment is
+    considered as failed: stranded workers must be visible, not a log line.
+    """
+    configure_logging()
+    ensure_safe_run()
+
+    release_name: str = os.environ["CHARTREUSE_RELEASE_NAME"]
+
+    deployment_manager = KubernetesDeploymentManager(release_name=release_name, use_kubeconfig=None)
+    deployment_manager.restore_stopped_pods()
+
+
+if __name__ == "__main__":
+    main()

{chartreuse-7.0.0.dev0 → chartreuse-7.0.1}/src/chartreuse/chartreuse_upgrade.py

@@ -1,12 +1,11 @@
 import logging
 import os
 
-from wiremind_kubernetes import KubernetesDeploymentManager
-
 from chartreuse import get_version
 
 from .chartreuse import Chartreuse
 from .config_loader import load_multi_database_config
+from .kubernetes_helper import KubernetesDeploymentManager
 
 logger = logging.getLogger(__name__)
 
@@ -20,10 +19,10 @@ def ensure_safe_run() -> None:
     # Get "1.2" from "1.2.3"
     package_v_major_minor: list[str] = package_v.split(".", 2)[:2]
 
-    helm_chart_v: str = os.getenv("HELM_CHART_VERSION", "")
+    helm_chart_v: str = os.getenv("HELM_CHART_APP_VERSION", "")
     if not helm_chart_v:
         raise ValueError(
-            "Couldn't get the Chartreuse's Helm Chart version from the env var HELM_CHART_VERSION,"
+            "Couldn't get the Chartreuse's Helm Chart appVersion from the env var HELM_CHART_APP_VERSION,"
             " couldn't make sure that the package is of a compatible version, ABORTING!"
         )
     helm_chart_v_major_minor: list[str] = helm_chart_v.split(".", 2)[:2]

{chartreuse-7.0.0.dev0 → chartreuse-7.0.1}/src/chartreuse/config_loader.py

@@ -39,7 +39,7 @@ class DatabaseConfig(BaseModel):
     @classmethod
     def validate_dialect(cls, v: str) -> str:
         """Validate database dialect."""
-        supported_dialects = ["postgresql+psycopg", "mysql", "sqlite", "oracle", "mssql", "clickhouse"]
+        supported_dialects = ["postgresql", "mysql", "sqlite", "oracle", "mssql", "clickhouse"]
         if v.lower() not in supported_dialects:
             logger.warning("Dialect '%s' might not be supported. Supported dialects: %s", v, supported_dialects)
         return v
@@ -86,7 +86,7 @@ def load_multi_database_config(config_path: str) -> dict[str, DatabaseConfig]:
     ```yaml
     databases:
       main:  # Database name/identifier
-        dialect: postgresql+psycopg
+        dialect: postgresql
         user: app_user
         password: app_password
         host: postgres-main
@@ -99,7 +99,7 @@ def load_multi_database_config(config_path: str) -> dict[str, DatabaseConfig]:
 
       # For single database setups, just include one database:
       # analytics:
-      #   dialect: postgresql+psycopg
+      #   dialect: postgresql
       #   user: analytics_user
       #   password: analytics_password
       #   host: postgres-analytics

chartreuse-7.0.1/src/chartreuse/kubernetes_helper.py

@@ -0,0 +1,424 @@
+"""
+Kubernetes helpers to stop, start and restore the application's Deployments around a database
+migration.
+
+Trimmed port of wiremind_kubernetes.KubernetesDeploymentManager (a library being
+decommissioned): only what chartreuse uses survived — ExpectedDeploymentScale-driven
+scale down/up with HPA disabling, plus the stopped-by annotation and restore logic.
+Depends only on the official kubernetes client.
+"""
+
+import functools
+import json
+import logging
+import os
+import pprint
+import time
+from collections.abc import Callable, Generator
+from typing import Any
+
+import kubernetes
+
+logger = logging.getLogger(__name__)
+
+# Target-rename prefix used by the pre-7.0.1 HPA disable mechanism. Only the repair path
+# (re_enable_hpa) remains, for HPAs left renamed by an older chartreuse.
+# TODO: remove in 8.0 together with re_enable_hpa.
+HPA_ID_PREFIX = "wm--disabled--kube"
+# Set by stop_pods() on every Deployment it scales down, cleared by start_pods() and
+# restore_stopped_pods(). Allows telling "stopped by us" apart from "deliberately scaled to 0".
+STOPPED_ANNOTATION = "wiremind.io/stopped-by"
+# Set by pause_hpa() on the HPA itself; stores the pre-pause spec.behavior as JSON ("" when
+# absent) so resume_hpa() can restore it exactly. Presence of the annotation == "paused by us".
+PAUSED_ANNOTATION = "wiremind.io/pre-pause-scale-behavior"
+
+
+def load_kubernetes_config(use_kubeconfig: bool | None = None) -> None:
+    """
+    Load kubernetes configuration in memory, either from incluster method or from kubeconfig.
+    :param use_kubeconfig:
+        If True: Use ~/.kube/config file to authenticate.
+        If False: use kubernetes built-in incluster mechanism.
+        If None, will try to load built-in incluster mechanism, then try config file.
+        Defaults to None.
+    """
+    if os.environ.get("CLASSIC_K8S_CONFIG"):
+        # We are in a Kind cluster for E2E test! Never use in cluster config.
+        kubernetes.config.load_kube_config()
+        return
+
+    if use_kubeconfig is True:
+        kubernetes.config.load_kube_config()
+    elif use_kubeconfig is False:
+        kubernetes.config.load_incluster_config()
+    elif use_kubeconfig is None:
+        if os.path.exists(kubernetes.config.incluster_config.SERVICE_TOKEN_FILENAME):
+            kubernetes.config.load_incluster_config()
+        else:
+            kubernetes.config.load_kube_config()
+    logger.debug("Kubernetes configuration successfully set.")
+
+
+def retry_kubernetes_request(function: Callable) -> Callable:
+    """
+    Decorator that retries a failed Kubernetes API request if needed and ignores 404
+    """
+
+    @functools.wraps(function)
+    def wrapper(*args: Any, **kwargs: Any) -> Any:
+        try:
+            return function(*args, **kwargs)
+        except kubernetes.client.rest.ApiException as e:
+            if e.status == 404:
+                logger.warning("Not found, ignoring.")
+                return
+            logger.error(e)
+            logger.info("Retrying in 5 seconds...")
+            time.sleep(5)
+            return function(*args, **kwargs)
+
+    return wrapper
+
+
+def retry_kubernetes_request_no_ignore(function: Callable) -> Callable:
+    """
+    Decorator that retries a failed Kubernetes API request if needed and do NOT ignore 404 (raise if 404)
+    """
+
+    @functools.wraps(function)
+    def wrapper(*args: Any, **kwargs: Any) -> Any:
+        try:
+            return function(*args, **kwargs)
+        except kubernetes.client.rest.ApiException as e:
+            if e.status == 404:
+                raise
+            logger.error(e)
+            logger.info("Retrying in 5 seconds...")
+            time.sleep(5)
+            return function(*args, **kwargs)
+
+    return wrapper
+
+
+def _get_namespace_from_kube() -> str:
+    return open("/var/run/secrets/kubernetes.io/serviceaccount/namespace").read()
+
+
+class KubernetesDeploymentManager:
+    """
+    Scale down/up all Deployments that should be stopped/started when doing database
+    migration/maintenance (alembic, dump, etc). Each managed Deployment must define an
+    ExpectedDeploymentScale.
+
+    Usage:
+    manager = KubernetesDeploymentManager(release_name="my-release", use_kubeconfig=None)
+    manager.stop_pods()
+    do_something('wololo')
+    manager.start_pods()
+    """
+
+    SCALE_DOWN_MAX_WAIT_TIME: int = 3600
+
+    def __init__(
+        self,
+        release_name: str,
+        use_kubeconfig: bool | None = False,
+        namespace: str | None = None,
+        should_load_kubernetes_config: bool = True,
+    ):
+        if should_load_kubernetes_config:
+            load_kubernetes_config(use_kubeconfig=use_kubeconfig)
+        self.release_name = release_name
+        self.namespace = namespace if namespace else _get_namespace_from_kube()
+        self.client_appsv1_api = kubernetes.client.AppsV1Api()
+        self.client_corev1_api = kubernetes.client.CoreV1Api()
+        self.client_autoscalingv2_api = kubernetes.client.AutoscalingV2Api()
+        self.client_custom_objects_api = kubernetes.client.CustomObjectsApi()
+
+    def get_deployment_scale(self, deployment_name: str) -> kubernetes.client.V1Scale:
+        logger.debug("Getting deployment scale for %s", deployment_name)
+        return self.client_appsv1_api.read_namespaced_deployment_scale(deployment_name, self.namespace)
+
+    @retry_kubernetes_request
+    def scale_down_deployment(self, deployment_name: str) -> None:
+        body = self.get_deployment_scale(deployment_name)
+        logger.debug("Deleting all Pods for %s", deployment_name)
+        body.spec.replicas = 0
+        self.client_appsv1_api.patch_namespaced_deployment_scale(deployment_name, self.namespace, body)
+        logger.debug("Done deleting.")
+
+    @retry_kubernetes_request
+    def scale_up_deployment(self, deployment_name: str, pod_amount: int) -> None:
+        body = self.get_deployment_scale(deployment_name)
+        logger.debug("Recreating backend Pods for %s", deployment_name)
+        body.spec.replicas = pod_amount
+        self.client_appsv1_api.patch_namespaced_deployment_scale(deployment_name, self.namespace, body)
+        logger.debug("Done recreating.")
+
+    @retry_kubernetes_request_no_ignore
+    def _get_pods_from_deployment(self, deployment_name: str) -> list:
+        logger.debug("Asking if Deployment %s is stopped", deployment_name)
+        labels = self.client_appsv1_api.read_namespaced_deployment(
+            deployment_name, self.namespace
+        ).spec.selector.match_labels
+
+        try:
+            return self.client_corev1_api.list_namespaced_pod(
+                namespace=self.namespace,
+                label_selector=",".join(["{}={}".format(*kv) for kv in labels.items()]),
+            ).items
+        except kubernetes.client.rest.ApiException as e:
+            if e.status == 404:
+                return []
+            else:
+                raise
+
+    def is_deployment_stopped(self, deployment_name: str) -> bool:
+        try:
+            pod_list: list = self._get_pods_from_deployment(deployment_name)
+        except kubernetes.client.rest.ApiException as e:
+            if e.status == 404:
+                logger.warning("Not found, ignoring.")
+                return True
+            raise
+
+        current_scale = 0
+        for pod in pod_list:
+            if pod.status.phase not in ("Failed"):
+                current_scale += 1
+
+        if current_scale > 0:
+            logger.info("%s Deployment has %s living replicas", deployment_name, current_scale)
+            return False
+        return True
+
+    def get_deployment_hpa(self, *, deployment_name: str) -> Generator:
+        for hpa in self.client_autoscalingv2_api.list_namespaced_horizontal_pod_autoscaler(self.namespace).items:
+            if hpa.spec.scale_target_ref.kind == "Deployment" and hpa.spec.scale_target_ref.name == deployment_name:
+                yield hpa
+
+    def patch_deployment_hpa(self, *, hpa_name: str, body: Any) -> None:
+        self.client_autoscalingv2_api.patch_namespaced_horizontal_pod_autoscaler(
+            name=hpa_name, namespace=self.namespace, body=body
+        )
+
+    @retry_kubernetes_request
+    def annotate_deployment(self, deployment_name: str, annotations: dict[str, str | None]) -> None:
+        """
+        Add or update annotations on a Deployment. A None value removes the annotation.
+        """
+        body = {"metadata": {"annotations": annotations}}
+        self.client_appsv1_api.patch_namespaced_deployment(deployment_name, self.namespace, body)
+
+    @retry_kubernetes_request_no_ignore
+    def _get_expected_deployment_scale_dict(self) -> dict[int, dict[str, int]]:
+        """
+        Return a dict of expected deployment scale:
+        {
+            0: {  # priority
+                # key: Deployment name, only if it has an associated eds
+                # value: expected Deployment Scale (replicas)
+                "my-deployment": 3,
+                "my-other-deployment": 42
+            },
+            1: {
+                "my-third-deployment": 17,
+            },
+        }
+        """
+        logger.debug("Getting Expected Deployment Scale list")
+        eds_list: list[dict[str, Any]] = []
+        release_label_keys = ["app.kubernetes.io/instance", "release"]
+
+        for release_label_key in release_label_keys:
+            logger.debug(f"Getting Expected Deployment Scale list with the release label key {release_label_key}")
+            try:
+                eds_list.extend(
+                    self.client_custom_objects_api.list_namespaced_custom_object(
+                        namespace=self.namespace,
+                        group="wiremind.io",
+                        version="v1",
+                        plural="expecteddeploymentscales",
+                        label_selector=f"{release_label_key}={self.release_name}",
+                    )["items"]
+                )
+            except kubernetes.client.rest.ApiException as e:
+                if e.status != 404:
+                    raise
+
+        eds_dict: dict[int, dict[str, int]] = {}
+        for eds in eds_list:
+            deployment_name: str = eds["spec"]["deploymentName"]
+            expected_scale: int = eds["spec"]["expectedScale"]
+            priority: int = eds["spec"].get("priority", 0)
+
+            if priority not in eds_dict:
+                eds_dict[priority] = {}
+
+            eds_dict[priority][deployment_name] = expected_scale
+
+        logger.debug("Deployments are %s", pprint.pformat(eds_dict))
+        return eds_dict
+
+    @retry_kubernetes_request
+    def pause_hpa(self, *, deployment_name: str) -> None:
+        """
+        Forbid the Deployment's HPAs from scaling up (spec.behavior.scaleUp.selectPolicy:
+        Disabled) so they can't start pods mid-migration. Unlike breaking the scaleTargetRef,
+        the HPA stays Healthy: no FailedGetScale events, no Degraded ArgoCD application.
+
+        The pre-pause spec.behavior is saved in PAUSED_ANNOTATION so resume_hpa() can restore
+        it exactly. Idempotent: an already-paused HPA is left alone (never overwrite the
+        saved original with a paused state).
+        """
+        for hpa in self.get_deployment_hpa(deployment_name=deployment_name):
+            if PAUSED_ANNOTATION in (hpa.metadata.annotations or {}):
+                continue
+            original_behavior = self.client_autoscalingv2_api.api_client.sanitize_for_serialization(hpa.spec.behavior)
+            saved = json.dumps(original_behavior) if original_behavior else ""
+            body = {
+                "metadata": {"annotations": {PAUSED_ANNOTATION: saved}},
+                "spec": {"behavior": {"scaleUp": {"selectPolicy": "Disabled"}}},
+            }
+            self.patch_deployment_hpa(hpa_name=hpa.metadata.name, body=body)
+
+    @retry_kubernetes_request
+    def resume_hpa(self, *, deployment_name: str) -> None:
+        """
+        Undo pause_hpa(): restore the exact pre-pause spec.behavior (or clear it when there
+        was none) and drop PAUSED_ANNOTATION. No-op on HPAs that don't carry the annotation,
+        so it is always safe to call.
+        """
+        for hpa in self.get_deployment_hpa(deployment_name=deployment_name):
+            saved = (hpa.metadata.annotations or {}).get(PAUSED_ANNOTATION)
+            if saved is None:
+                continue
+            body = {
+                "metadata": {"annotations": {PAUSED_ANNOTATION: None}},
+                "spec": {"behavior": json.loads(saved) if saved else None},
+            }
+            self.patch_deployment_hpa(hpa_name=hpa.metadata.name, body=body)
+
+    @retry_kubernetes_request
+    def re_enable_hpa(self, *, deployment_name: str) -> None:
+        """
+        Repair an HPA left pointing at a wm--disabled--kube- target by a pre-7.0.1 chartreuse
+        whose run crashed before re-enabling. 7.0.1+ never creates such renames.
+        TODO: remove in 8.0.
+        """
+        for hpa in self.get_deployment_hpa(deployment_name=f"{HPA_ID_PREFIX}-{deployment_name}"):
+            hpa.spec.scale_target_ref.name = deployment_name
+            self.patch_deployment_hpa(hpa_name=hpa.metadata.name, body=hpa)
+
+    def _are_deployments_stopped(self, deployment_dict: dict[str, int]) -> bool:
+        for deployment_name in deployment_dict:
+            if not self.is_deployment_stopped(deployment_name):
+                return False
+        return True
+
+    def _stop_deployments(self, deployment_dict: dict[str, int]) -> None:
+        """
+        Scale down a dict (deployment_name, expected_scale) of Deployments.
+        """
+        for deployment_name in deployment_dict:
+            self.annotate_deployment(deployment_name, {STOPPED_ANNOTATION: self.release_name})
+            self.pause_hpa(deployment_name=deployment_name)
+        for _ in range(self.SCALE_DOWN_MAX_WAIT_TIME):
+            for deployment_name in deployment_dict:
+                self.scale_down_deployment(deployment_name)
+            if self._are_deployments_stopped(deployment_dict):
+                break
+            time.sleep(1)
+        else:
+            raise Exception("Timed out waiting for pods to be deleted: aborting.")
+
+    def stop_pods(self) -> None:
+        """
+        Scale to 0 all deployments for which an ExpectedDeploymentScale links to.
+        stop all deployments, then wait for actual stop, by priority (descending order):
+        Example: stop all deployments with priority 1, then all deployments with priority 0
+        """
+        expected_deployment_scale_dict: dict[int, dict[str, int]] = self._get_expected_deployment_scale_dict()
+
+        logger.info("Scaling down application Deployments...")
+        if not expected_deployment_scale_dict:
+            logger.info("No Deployments to scale down")
+            return
+
+        priorities: list[int] = sorted(expected_deployment_scale_dict, reverse=True)
+        for priority in priorities:
+            priority_dict: dict[str, int] = expected_deployment_scale_dict[priority]
+            if len(priority_dict):
+                self._stop_deployments(priority_dict)
+        logger.info("Done scaling down application Deployments.")
+
+    def start_pods(self) -> None:
+        """
+        Start all Pods that should be started
+        """
+        expected_deployment_scale_dict: dict[int, dict[str, int]] = self._get_expected_deployment_scale_dict()
+
+        logger.info("Scaling up application Deployments...")
+        if not expected_deployment_scale_dict:
+            logger.info("No Deployments to scale up")
+            return
+
+        scaled: bool = False
+        for priority_dict in expected_deployment_scale_dict.values():
+            if len(priority_dict):
+                scaled = True
+                for name, expected_scale in priority_dict.items():
+                    self.resume_hpa(deployment_name=name)
+                    self.re_enable_hpa(deployment_name=name)
+                    self.scale_up_deployment(name, expected_scale)
+                    self.annotate_deployment(name, {STOPPED_ANNOTATION: None})
+        if scaled:
+            logger.info("Done scaling up application Deployments")
+        else:
+            logger.info("No Deployments to scale up")
+
+    def restore_stopped_pods(self) -> None:
+        """
+        Restore Deployments that stop_pods() scaled down and that nothing scaled back up since.
+
+        Only the replica restore is gated on STOPPED_ANNOTATION, so a Deployment deliberately
+        scaled to zero outside of stop_pods() is left alone. HPA resume/repair on the other
+        hand runs for EVERY tracked Deployment: a pause left behind by a crashed run is not
+        self-healing (ArgoCD ignores the live-only spec.behavior field), and resuming an
+        unpaused HPA is a no-op.
+
+        Meant to run after the deployment that follows a stop_pods() without start_pods()
+        (CHARTREUSE_UPGRADE_BEFORE_DEPLOYMENT): that deployment restores spec.replicas of
+        Deployments that define it in their chart, but HPA-managed ones omit it, and an HPA
+        whose target is at 0 replicas with minReplicas >= 1 is ScalingDisabled and will never
+        scale it back up.
+        """
+        expected_deployment_scale_dict: dict[int, dict[str, int]] = self._get_expected_deployment_scale_dict()
+
+        logger.info("Restoring Deployments left stopped...")
+        restored: list[str] = []
+        for priority in sorted(expected_deployment_scale_dict):
+            for name, expected_scale in expected_deployment_scale_dict[priority].items():
+                self.resume_hpa(deployment_name=name)
+                self.re_enable_hpa(deployment_name=name)
+                try:
+                    deployment = self.client_appsv1_api.read_namespaced_deployment(name, self.namespace)
+                except kubernetes.client.rest.ApiException as e:
+                    if e.status == 404:
+                        continue
+                    raise
+                if STOPPED_ANNOTATION not in (deployment.metadata.annotations or {}):
+                    continue
+                if not deployment.spec.replicas:
+                    target_scale = expected_scale
+                    if target_scale < 1 and any(self.get_deployment_hpa(deployment_name=name)):
+                        # Any scale >= 1 re-arms the HPA, which then enforces its own minReplicas
+                        target_scale = 1
+                    if target_scale > 0:
+                        self.scale_up_deployment(name, target_scale)
+                self.annotate_deployment(name, {STOPPED_ANNOTATION: None})
+                restored.append(name)
+        if restored:
+            logger.info("Done restoring stopped Deployments: %s", ", ".join(restored))
+        else:
+            logger.info("No stopped Deployments to restore")

{chartreuse-7.0.0.dev0 → chartreuse-7.0.1}/src/chartreuse/utils/alembic_migration_helper.py

@@ -5,7 +5,8 @@ from subprocess import SubprocessError
 
 import sqlalchemy
 from sqlalchemy import inspect
-from wiremind_kubernetes.utils import run_command
+
+from .command import run_command
 
 logger = logging.getLogger(__name__)
 

chartreuse-7.0.1/src/chartreuse/utils/command.py

@@ -0,0 +1,40 @@
+import logging
+import shlex
+import subprocess
+
+logger = logging.getLogger(__name__)
+
+
+def run_command(command: list | str, return_result: bool = False, **kw_args) -> tuple[str, str, int]:
+    """
+    Run command, print stdout/stderr, check that command exited correctly, return stdout/err
+    """
+    logger.debug(f"Running {command}")
+
+    interpreted_command: list[str]
+    if isinstance(command, str):
+        interpreted_command = shlex.split(command)
+    else:
+        interpreted_command = command
+
+    process = subprocess.Popen(
+        interpreted_command,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        universal_newlines=True,
+        **kw_args,
+    )
+
+    if return_result:
+        out, err = process.communicate()
+        return (out, err, process.returncode)
+
+    if process.stdout:
+        for line in iter(process.stdout.readline, ""):
+            logger.info(line.strip())
+    process.wait()
+
+    if process.returncode:
+        raise subprocess.CalledProcessError(process.returncode, command)
+
+    return "", "", 0

{chartreuse-7.0.0.dev0 → chartreuse-7.0.1/src/chartreuse.egg-info}/PKG-INFO

@@ -1,18 +1,21 @@
 Metadata-Version: 2.4
 Name: chartreuse
-Version: 7.0.0.dev0
+Version: 7.0.1
 Summary: Helper for Alembic migrations within Kubernetes.
 Author-email: wiremind <dev@wiremind.io>
 License-Expression: LGPL-3.0-or-later
 Project-URL: github, https://github.com/wiremind/chartreuse
-Requires-Python: >=3.11.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.13.0
 Description-Content-Type: text/markdown
 License-File: LICENCE.md
 Requires-Dist: alembic
-Requires-Dist: psycopg[binary]
+Requires-Dist: kubernetes
+Requires-Dist: psycopg2
 Requires-Dist: pydantic>=2.0.0
 Requires-Dist: PyYAML
-Requires-Dist: wiremind-kubernetes~=7.0
 Provides-Extra: test
 Requires-Dist: mock; extra == "test"
 Requires-Dist: pytest; extra == "test"
@@ -40,7 +43,7 @@ Chartreuse leverages [Helm Hooks](https://helm.sh/docs/topics/charts_hooks/), th
 
 ### Requirements
 
-- Python >= 3.7
+- Python >= 3.13
 - Using Helm to deploy you application
 - This Python package requires the `expecteddeploymentscales.wiremind.io` Kubernetes `Custom Resource Definition`:
 

{chartreuse-7.0.0.dev0 → chartreuse-7.0.1}/src/chartreuse.egg-info/SOURCES.txt

@@ -5,8 +5,10 @@ VERSION
 pyproject.toml
 src/chartreuse/__init__.py
 src/chartreuse/chartreuse.py
+src/chartreuse/chartreuse_restore.py
 src/chartreuse/chartreuse_upgrade.py
 src/chartreuse/config_loader.py
+src/chartreuse/kubernetes_helper.py
 src/chartreuse.egg-info/PKG-INFO
 src/chartreuse.egg-info/SOURCES.txt
 src/chartreuse.egg-info/dependency_links.txt
@@ -15,4 +17,5 @@ src/chartreuse.egg-info/requires.txt
 src/chartreuse.egg-info/top_level.txt
 src/chartreuse.egg-info/zip-safe
 src/chartreuse/utils/__init__.py
-src/chartreuse/utils/alembic_migration_helper.py
+src/chartreuse/utils/alembic_migration_helper.py
+src/chartreuse/utils/command.py

{chartreuse-7.0.0.dev0 → chartreuse-7.0.1}/src/chartreuse.egg-info/entry_points.txt

@@ -1,2 +1,3 @@
 [console_scripts]
+chartreuse-restore = chartreuse.chartreuse_restore:main
 chartreuse-upgrade = chartreuse.chartreuse_upgrade:main

{chartreuse-7.0.0.dev0 → chartreuse-7.0.1}/src/chartreuse.egg-info/requires.txt

@@ -1,8 +1,8 @@
 alembic
-psycopg[binary]
+kubernetes
+psycopg2
 pydantic>=2.0.0
 PyYAML
-wiremind-kubernetes~=7.0
 
 [dev]
 ruff

chartreuse-7.0.0.dev0/VERSION

@@ -1 +0,0 @@
-7.0.0-dev0