qontract-reconcile 0.10.2.dev262__tar.gz → 0.10.2.dev264__tar.gz

{qontract_reconcile-0.10.2.dev262 → qontract_reconcile-0.10.2.dev264}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qontract-reconcile
-Version: 0.10.2.dev262
+Version: 0.10.2.dev264
 Summary: Collection of tools to reconcile services with their desired state as defined in the app-interface DB.
 Project-URL: homepage, https://github.com/app-sre/qontract-reconcile
 Project-URL: repository, https://github.com/app-sre/qontract-reconcile

{qontract_reconcile-0.10.2.dev262 → qontract_reconcile-0.10.2.dev264}/pyproject.toml

@@ -262,14 +262,6 @@ disallow_incomplete_defs = true
 [[tool.mypy.overrides]]
 # Untyped modules
 module = [
-    "reconcile.mr_client_gateway",
-    "reconcile.ocm_additional_routers",
-    "reconcile.ocm_addons",
-    "reconcile.ocm_aws_infrastructure_access",
-    "reconcile.ocm_clusters",
-    "reconcile.ocm_external_configuration_labels",
-    "reconcile.ocm_groups",
-    "reconcile.ocm_machine_pools",
     "reconcile.ocm_upgrade_scheduler_org_updater",
     "reconcile.openshift_base",
     "reconcile.openshift_clusterrolebindings",
@@ -371,10 +363,6 @@ module = [
     "reconcile.test.test_jenkins_worker_fleets",
     "reconcile.test.test_jump_host",
     "reconcile.test.test_make",
-    "reconcile.test.test_ocm_additional_routers",
-    "reconcile.test.test_ocm_clusters_manifest_updates",
-    "reconcile.test.test_ocm_clusters",
-    "reconcile.test.test_ocm_machine_pools",
     "reconcile.test.test_ocm_update_recommended_version",
     "reconcile.test.test_ocm_upgrade_scheduler_org_updater",
     "reconcile.test.test_openshift_base",

{qontract_reconcile-0.10.2.dev262 → qontract_reconcile-0.10.2.dev264}/reconcile/cli.py

@@ -2944,12 +2944,11 @@ def ocm_update_recommended_version(
 
 
 @integration.command(short_help="Manages cluster Addons in OCM.")
-@threaded()
 @click.pass_context
-def ocm_addons(ctx: click.Context, thread_pool_size: int) -> None:
+def ocm_addons(ctx: click.Context) -> None:
     import reconcile.ocm_addons
 
-    run_integration(reconcile.ocm_addons, ctx, thread_pool_size)
+    run_integration(reconcile.ocm_addons, ctx)
 
 
 @integration.command(

{qontract_reconcile-0.10.2.dev262 → qontract_reconcile-0.10.2.dev264}/reconcile/mr_client_gateway.py

@@ -27,14 +27,19 @@ MR_GW_QUERY = """
 def get_mr_gateway_settings() -> Mapping[str, Any]:
     """Returns SecretReader settings"""
     gqlapi = gql.get_api()
-    settings = gqlapi.query(MR_GW_QUERY)["settings"]
+    data = gqlapi.query(MR_GW_QUERY)
+    if not data:
+        raise ValueError("no app-interface-settings found from gql query")
+    settings = data.get("settings")
     if settings:
         # assuming a single settings file for now
         return settings[0]
     raise ValueError("no app-interface-settings found")
 
 
-def init(gitlab_project_id=None, sqs_or_gitlab=None):
+def init(
+    gitlab_project_id: str | int | None = None, sqs_or_gitlab: str | None = None
+) -> GitLabApi | SQSGateway:
     """
     Creates the Merge Request client to of a given type.
 

{qontract_reconcile-0.10.2.dev262 → qontract_reconcile-0.10.2.dev264}/reconcile/ocm_additional_routers.py

@@ -1,7 +1,7 @@
 import json
 import logging
 import sys
-from collections.abc import Mapping
+from collections.abc import Iterable, Mapping, MutableMapping
 from typing import Any
 
 from reconcile import queries
@@ -17,7 +17,9 @@ QONTRACT_INTEGRATION = "ocm-additional-routers"
 SUPPORTED_OCM_PRODUCTS = [OCM_PRODUCT_OSD]
 
 
-def fetch_current_state(clusters):
+def fetch_current_state(
+    clusters: list[Mapping[str, Any]],
+) -> tuple[OCMMap, list[dict[str, Any]]]:
     settings = queries.get_app_interface_settings()
     ocm_map = OCMMap(
         clusters=clusters, integration=QONTRACT_INTEGRATION, settings=settings
@@ -35,13 +37,13 @@ def fetch_current_state(clusters):
     return ocm_map, current_state
 
 
-def fetch_desired_state(clusters):
+def fetch_desired_state(clusters: Iterable[Mapping[str, Any]]) -> list[dict[str, Any]]:
     desired_state = []
     for cluster in clusters:
         cluster_name = cluster["name"]
         for router in cluster["additionalRouters"]:
             listening = "internal" if router["private"] else "external"
-            item = {"listening": listening, "cluster": cluster_name}
+            item: dict[str, Any] = {"listening": listening, "cluster": cluster_name}
             selectors = router.get("route_selectors", None)
             if selectors:
                 item["route_selectors"] = json.loads(selectors)
@@ -50,31 +52,34 @@ def fetch_desired_state(clusters):
     return desired_state
 
 
-def calculate_diff(current_state, desired_state):
+def calculate_diff(
+    current_state: Iterable[MutableMapping[str, Any]],
+    desired_state: Iterable[MutableMapping[str, Any]],
+) -> list[MutableMapping[str, Any]]:
     diffs = []
-    for d in desired_state:
-        c = [c for c in current_state if d.items() <= c.items()]
-        if not c:
-            d["action"] = "create"
-            diffs.append(d)
-
-    for c in current_state:
-        d = [d for d in desired_state if d.items() <= c.items()]
-        if not d:
-            c["action"] = "delete"
-            diffs.append(c)
+    for d_item in desired_state:
+        c_items = [c for c in current_state if d_item.items() <= c.items()]
+        if not c_items:
+            d_item["action"] = "create"
+            diffs.append(d_item)
+
+    for c_item in current_state:
+        d_items = [d for d in desired_state if d.items() <= c_item.items()]
+        if not d_items:
+            c_item["action"] = "delete"
+            diffs.append(c_item)
 
     return diffs
 
 
-def sort_diffs(diff):
+def sort_diffs(diff: Mapping[str, Any]) -> int:
     """Sort diffs so we delete first and create later"""
     if diff["action"] == "delete":
         return 1
     return 2
 
 
-def act(dry_run, diffs, ocm_map):
+def act(dry_run: bool, diffs: list[MutableMapping[str, Any]], ocm_map: OCMMap) -> None:
     diffs.sort(key=sort_diffs)
     for diff in diffs:
         action = diff.pop("action")
@@ -82,6 +87,9 @@ def act(dry_run, diffs, ocm_map):
         logging.info([action, cluster])
         if not dry_run:
             ocm = ocm_map.get(cluster)
+            if ocm is None:
+                logging.error(f"OCM client for cluster {cluster} not found.")
+                continue
             if action == "create":
                 ocm.create_additional_router(cluster, diff)
             elif action == "delete":
@@ -96,11 +104,10 @@ def _cluster_is_compatible(cluster: Mapping[str, Any]) -> bool:
     )
 
 
-def run(dry_run):
-    clusters = queries.get_clusters()
+def run(dry_run: bool) -> None:
     clusters = [
         c
-        for c in clusters
+        for c in queries.get_clusters()
         if integration_is_enabled(QONTRACT_INTEGRATION, c) and _cluster_is_compatible(c)
     ]
     if not clusters:

{qontract_reconcile-0.10.2.dev262 → qontract_reconcile-0.10.2.dev264}/reconcile/ocm_addons.py

@@ -1,6 +1,6 @@
 import logging
 import sys
-from collections.abc import Mapping
+from collections.abc import Iterable, Mapping, MutableMapping
 from operator import itemgetter
 from typing import Any
 
@@ -12,7 +12,9 @@ from reconcile.utils.ocm import OCMMap
 QONTRACT_INTEGRATION = "ocm-addons"
 
 
-def fetch_current_state(clusters):
+def fetch_current_state(
+    clusters: Iterable[Mapping[str, Any]],
+) -> tuple[OCMMap, list[dict[str, Any]]]:
     settings = queries.get_app_interface_settings()
     ocm_map = OCMMap(
         clusters=clusters,
@@ -35,7 +37,7 @@ def fetch_current_state(clusters):
     return ocm_map, current_state
 
 
-def fetch_desired_state(clusters):
+def fetch_desired_state(clusters: Iterable[Mapping[str, Any]]) -> list[dict[str, Any]]:
     desired_state = []
     for cluster in clusters:
         cluster_name = cluster["name"]
@@ -49,13 +51,16 @@ def fetch_desired_state(clusters):
     return desired_state
 
 
-def sort_parameters(addon):
+def sort_parameters(addon: MutableMapping[str, Any]) -> None:
     addon_parameters = addon.get("parameters")
     if addon_parameters:
         addon["parameters"] = sorted(addon_parameters, key=itemgetter("id"))
 
 
-def calculate_diff(current_state, desired_state):
+def calculate_diff(
+    current_state: Iterable[Mapping[str, Any]],
+    desired_state: Iterable[MutableMapping[str, Any]],
+) -> list[MutableMapping[str, Any]]:
     diffs = []
     for d in desired_state:
         c = [c for c in current_state if d.items() <= c.items()]
@@ -66,7 +71,9 @@ def calculate_diff(current_state, desired_state):
     return diffs
 
 
-def act(dry_run, diffs, ocm_map):
+def act(
+    dry_run: bool, diffs: Iterable[MutableMapping[str, Any]], ocm_map: OCMMap
+) -> bool:
     err = False
     for diff in diffs:
         action = diff.pop("action")
@@ -95,7 +102,7 @@ def _cluster_is_compatible(cluster: Mapping[str, Any]) -> bool:
     return cluster.get("ocm") is not None and cluster.get("addons") is not None
 
 
-def run(dry_run, gitlab_project_id=None, thread_pool_size=10):
+def run(dry_run: bool) -> None:
     clusters = queries.get_clusters()
     clusters = [
         c

{qontract_reconcile-0.10.2.dev262 → qontract_reconcile-0.10.2.dev264}/reconcile/ocm_aws_infrastructure_access.py

@@ -1,6 +1,6 @@
 import logging
 import sys
-from collections.abc import Mapping
+from collections.abc import Iterable, Mapping
 from typing import Any
 
 from reconcile import queries
@@ -22,7 +22,9 @@ QONTRACT_INTEGRATION = "ocm-aws-infrastructure-access"
 SUPPORTED_OCM_PRODUCTS = [OCM_PRODUCT_OSD]
 
 
-def fetch_current_state(clusters):
+def fetch_current_state(
+    clusters: Iterable[Mapping[str, Any]],
+) -> tuple[OCMMap, list[dict[str, Any]], list[dict[str, Any]], list[dict[str, Any]]]:
     current_state = []
     current_failed = []
     current_deleting = []
@@ -52,7 +54,7 @@ def fetch_current_state(clusters):
     return ocm_map, current_state, current_failed, current_deleting
 
 
-def fetch_desired_state(clusters):
+def fetch_desired_state(clusters: Iterable[Mapping[str, Any]]) -> list[dict[str, Any]]:
     desired_state = []
 
     for cluster_info in clusters:
@@ -129,8 +131,13 @@ def fetch_desired_state(clusters):
 
 
 def act(
-    dry_run, ocm_map, current_state, current_failed, desired_state, current_deleting
-):
+    dry_run: bool,
+    ocm_map: OCMMap,
+    current_state: list[dict[str, Any]],
+    current_failed: Iterable[dict[str, Any]],
+    desired_state: Iterable[dict[str, Any]],
+    current_deleting: list[dict[str, Any]],
+) -> None:
     to_delete = [c for c in current_state if c not in desired_state]
     to_delete += current_failed
     for item in to_delete:
@@ -173,7 +180,7 @@ def _cluster_is_compatible(cluster: Mapping[str, Any]) -> bool:
     )
 
 
-def get_clusters():
+def get_clusters() -> list[dict[str, Any]]:
     return [
         c
         for c in queries.get_clusters(aws_infrastructure_access=True)
@@ -181,7 +188,7 @@ def get_clusters():
     ]
 
 
-def run(dry_run):
+def run(dry_run: bool) -> None:
     clusters = get_clusters()
     if not clusters:
         logging.debug(

{qontract_reconcile-0.10.2.dev262 → qontract_reconcile-0.10.2.dev264}/reconcile/ocm_clusters.py

@@ -40,7 +40,7 @@ QONTRACT_INTEGRATION = "ocm-clusters"
 QONTRACT_INTEGRATION_VERSION = make_semver(0, 1, 0)
 
 
-def _set_rosa_ocm_attrs(cluster: Mapping[str, Any]):
+def _set_rosa_ocm_attrs(cluster: Mapping[str, Any]) -> None:
     """Cluster account (aws) attribute from app-interface differs from the OCMSpec.
     app-interface's account includes the details for all the OCM environments
     but the cluster only needs the target OCM environment where it belongs.
@@ -78,8 +78,7 @@ def _set_rosa_ocm_attrs(cluster: Mapping[str, Any]):
 
     # doing this allows to exclude account fields which can be queried in graphql
     rosa_cluster_aws_account = ROSAClusterAWSAccount(
-        uid=uid,
-        rosa=rosa,
+        uid=uid, rosa=rosa, billing_account_id=None
     )
     if billing_account := account.get("billingAccount"):
         rosa_cluster_aws_account.billing_account_id = billing_account["uid"]
@@ -293,7 +292,7 @@ def get_cluster_ocm_update_spec(
 
 def _app_interface_updates_mr(
     clusters_updates: Mapping[str, Any], gitlab_project_id: str | None, dry_run: bool
-):
+) -> None:
     """Creates an MR to app-interface with the necessary cluster manifest updates
 
     :param clusters_updates: Updates to perform. Format required by the MR utils code

{qontract_reconcile-0.10.2.dev262 → qontract_reconcile-0.10.2.dev264}/reconcile/ocm_external_configuration_labels.py

@@ -1,7 +1,7 @@
 import json
 import logging
 import sys
-from collections.abc import Mapping
+from collections.abc import Iterable, Mapping
 from typing import Any
 
 from reconcile import queries
@@ -12,14 +12,16 @@ from reconcile.utils.ocm import OCMMap
 QONTRACT_INTEGRATION = "ocm-external-configuration-labels"
 
 
-def get_allowed_labels_for_cluster(cluster: dict[str, Any]) -> set[str]:
+def get_allowed_labels_for_cluster(cluster: Mapping[str, Any]) -> set[str]:
     allowed_labels = cluster.get("ocm", {}).get(
         "allowedClusterExternalConfigLabels", []
     )
     return set(allowed_labels)
 
 
-def fetch_current_state(clusters):
+def fetch_current_state(
+    clusters: Iterable[Mapping[str, Any]],
+) -> tuple[OCMMap, list[dict[str, Any]]]:
     settings = queries.get_app_interface_settings()
     ocm_map = OCMMap(
         clusters=clusters, integration=QONTRACT_INTEGRATION, settings=settings
@@ -34,13 +36,16 @@ def fetch_current_state(clusters):
         for key, value in labels.items():
             if key not in allowed_labels:
                 continue
-            item = {"label": {"key": key, "value": value}, "cluster": cluster_name}
+            item = {
+                "label": {"key": key, "value": value},
+                "cluster": cluster_name,
+            }
             current_state.append(item)
 
     return ocm_map, current_state
 
 
-def fetch_desired_state(clusters):
+def fetch_desired_state(clusters: Iterable[Mapping[str, Any]]) -> list[dict[str, Any]]:
     desired_state = []
     for cluster in clusters:
         cluster_name = cluster["name"]
@@ -57,32 +62,35 @@ def fetch_desired_state(clusters):
     return desired_state
 
 
-def calculate_diff(current_state, desired_state):
+def calculate_diff(
+    current_state: Iterable[dict[str, Any]],
+    desired_state: Iterable[dict[str, Any]],
+) -> tuple[list[dict[str, Any]], bool]:
     diffs = []
     err = False
-    for d in desired_state:
-        c = [c for c in current_state if d == c]
-        if not c:
-            d["action"] = "create"
-            diffs.append(d)
-
-    for c in current_state:
-        d = [d for d in desired_state if c == d]
-        if not d:
-            c["action"] = "delete"
-            diffs.append(c)
+    for d_item in desired_state:
+        c_items = [c for c in current_state if d_item == c]
+        if not c_items:
+            d_item["action"] = "create"
+            diffs.append(d_item)
+
+    for c_item in current_state:
+        d_items = [d for d in desired_state if c_item == d]
+        if not d_items:
+            c_item["action"] = "delete"
+            diffs.append(c_item)
 
     return diffs, err
 
 
-def sort_diffs(diff):
+def sort_diffs(diff: Mapping[str, Any]) -> int:
     """Sort diffs so we delete first and create later"""
     if diff["action"] == "delete":
         return 1
     return 2
 
 
-def act(dry_run, diffs, ocm_map):
+def act(dry_run: bool, diffs: list[dict[str, Any]], ocm_map: OCMMap) -> None:
     diffs.sort(key=sort_diffs)
     for diff in diffs:
         action = diff["action"]
@@ -104,7 +112,11 @@ def _cluster_is_compatible(cluster: Mapping[str, Any]) -> bool:
     )
 
 
-def run(dry_run, gitlab_project_id=None, thread_pool_size=10):
+def run(
+    dry_run: bool,
+    gitlab_project_id: str | None = None,
+    thread_pool_size: int = 10,
+) -> None:
     clusters = queries.get_clusters()
     clusters = [
         c

{qontract_reconcile-0.10.2.dev262 → qontract_reconcile-0.10.2.dev264}/reconcile/ocm_groups.py

@@ -1,7 +1,10 @@
 import itertools
 import logging
 import sys
-from collections.abc import Mapping
+from collections.abc import (
+    Iterable,
+    Mapping,
+)
 from typing import Any
 
 from sretoolbox.utils import threaded
@@ -18,7 +21,20 @@ from reconcile.utils.ocm.base import OCMClusterGroupId
 QONTRACT_INTEGRATION = "ocm-groups"
 
 
-def get_cluster_state(group_items, ocm_map):
+def create_groups_list(clusters: Iterable[Mapping[str, Any]]) -> list[dict[str, str]]:
+    groups_list: list[dict[str, str]] = []
+    for cluster_info in clusters:
+        cluster = cluster_info["name"]
+        groups = cluster_info["managedGroups"] or []
+        groups_list.extend(
+            {"cluster": cluster, "group_name": group_name} for group_name in groups
+        )
+    return groups_list
+
+
+def get_cluster_state(
+    group_items: Mapping[str, str], ocm_map: OCMMap
+) -> list[dict[str, str]]:
     cluster = group_items["cluster"]
     ocm = ocm_map.get(cluster)
     group_name = group_items["group_name"]
@@ -27,17 +43,18 @@ def get_cluster_state(group_items, ocm_map):
         return []
     return [
         {"cluster": cluster, "group": group_name, "user": user}
-        for user in group["users"] or []
+        for user in group.get("users") or []
     ]
 
 
-def fetch_current_state(clusters, thread_pool_size):
-    current_state = []
+def fetch_current_state(
+    clusters: Iterable[Mapping[str, Any]], thread_pool_size: int
+) -> tuple[OCMMap, list[dict[str, str]]]:
     settings = queries.get_app_interface_settings()
     ocm_map = OCMMap(
         clusters=clusters, integration=QONTRACT_INTEGRATION, settings=settings
     )
-    groups_list = openshift_groups.create_groups_list(clusters, oc_map=ocm_map)
+    groups_list = create_groups_list(clusters)
     results = threaded.run(
         get_cluster_state, groups_list, thread_pool_size, ocm_map=ocm_map
     )
@@ -46,7 +63,7 @@ def fetch_current_state(clusters, thread_pool_size):
     return ocm_map, current_state
 
 
-def act(diff, ocm_map):
+def act(diff: Mapping[str, Any], ocm_map: OCMMap) -> None:
     cluster = diff["cluster"]
     group = diff["group"]
     user = diff["user"]
@@ -63,8 +80,12 @@ def _cluster_is_compatible(cluster: Mapping[str, Any]) -> bool:
     return cluster.get("ocm") is not None
 
 
-def run(dry_run, thread_pool_size=10):
+def run(dry_run: bool, thread_pool_size: int = 10) -> None:
     clusters = queries.get_clusters()
+    if not clusters:
+        logging.debug("No clusters found in app-interface")
+        sys.exit(ExitCodes.SUCCESS)
+
     clusters = [
         c
         for c in clusters
@@ -97,10 +118,10 @@ def run(dry_run, thread_pool_size=10):
             act(diff, ocm_map)
 
 
-def early_exit_desired_state(*args, **kwargs) -> dict[str, Any]:
+def early_exit_desired_state(*args: Any, **kwargs: Any) -> dict[str, Any]:
     clusters = [
         c["name"]
-        for c in queries.get_clusters()
+        for c in queries.get_clusters() or []
         if integration_is_enabled(QONTRACT_INTEGRATION, c) and _cluster_is_compatible(c)
     ]
     desired_state = openshift_groups.fetch_desired_state(clusters=clusters)

{qontract_reconcile-0.10.2.dev262 → qontract_reconcile-0.10.2.dev264}/reconcile/ocm_machine_pools.py

@@ -5,6 +5,7 @@ from abc import (
 )
 from collections.abc import Iterable, Mapping
 from enum import Enum
+from typing import Any, Self
 
 from pydantic import (
     BaseModel,
@@ -48,11 +49,11 @@ class AbstractAutoscaling(BaseModel):
         )
 
     @abstractmethod
-    def get_min(self):
+    def get_min(self) -> int:
         pass
 
     @abstractmethod
-    def get_max(self):
+    def get_max(self) -> int:
         pass
 
 
@@ -61,9 +62,12 @@ class MachinePoolAutoscaling(AbstractAutoscaling):
     max_replicas: int
 
     @root_validator()
-    @classmethod
-    def max_greater_min(cls, field_values):
-        if field_values.get("min_replicas") > field_values.get("max_replicas"):
+    def max_greater_min(cls, field_values: Mapping[str, Any]) -> Mapping[str, Any]:
+        min_replicas = field_values.get("min_replicas")
+        max_replicas = field_values.get("max_replicas")
+        if min_replicas is None or max_replicas is None:
+            raise ValueError("min_replicas and max_replicas must be set")
+        if min_replicas > max_replicas:
             raise ValueError("max_replicas must be greater than min_replicas")
         return field_values
 
@@ -79,10 +83,13 @@ class NodePoolAutoscaling(AbstractAutoscaling):
     max_replica: int
 
     @root_validator()
-    @classmethod
-    def max_greater_min(cls, field_values):
-        if field_values.get("min_replica") > field_values.get("max_replica"):
-            raise ValueError("max_replicas must be greater than min_replicas")
+    def max_greater_min(cls, field_values: Mapping[str, Any]) -> Mapping[str, Any]:
+        min_replica = field_values.get("min_replica")
+        max_replica = field_values.get("max_replica")
+        if min_replica is None or max_replica is None:
+            raise ValueError("min_replica and max_replica must be set")
+        if min_replica > max_replica:
+            raise ValueError("max_replica must be greater than min_replica")
         return field_values
 
     def get_min(self) -> int:
@@ -104,8 +111,7 @@ class AbstractPool(ABC, BaseModel):
     autoscaling: AbstractAutoscaling | None
 
     @root_validator()
-    @classmethod
-    def validate_scaling(cls, field_values):
+    def validate_scaling(cls, field_values: Mapping[str, Any]) -> Mapping[str, Any]:
         if field_values.get("autoscaling") and field_values.get("replicas"):
             raise ValueError("autoscaling and replicas are mutually exclusive")
         return field_values
@@ -134,14 +140,12 @@ class AbstractPool(ABC, BaseModel):
     def deletable(self) -> bool:
         pass
 
-    def _has_diff_autoscale(self, pool):
-        match (self.autoscaling, pool.autoscale):
-            case (None, None):
-                return False
-            case (None, _) | (_, None):
-                return True
-            case _:
-                return self.autoscaling.has_diff(pool.autoscale)
+    def _has_diff_autoscale(self, pool: ClusterMachinePoolV1) -> bool:
+        if self.autoscaling is None and pool.autoscale is None:
+            return False
+        if self.autoscaling is None or pool.autoscale is None:
+            return True
+        return self.autoscaling.has_diff(pool.autoscale)
 
 
 class MachinePool(AbstractPool):
@@ -198,7 +202,7 @@ class MachinePool(AbstractPool):
         pool: ClusterMachinePoolV1,
         cluster: str,
         cluster_type: ClusterType,
-    ):
+    ) -> Self:
         autoscaling: MachinePoolAutoscaling | None = None
         if pool.autoscale:
             autoscaling = MachinePoolAutoscaling(
@@ -278,7 +282,7 @@ class NodePool(AbstractPool):
         pool: ClusterMachinePoolV1,
         cluster: str,
         cluster_type: ClusterType,
-    ):
+    ) -> Self:
         autoscaling: NodePoolAutoscaling | None = None
         if pool.autoscale:
             autoscaling = NodePoolAutoscaling(
@@ -369,7 +373,7 @@ def _classify_cluster_type(cluster: ClusterV1) -> ClusterType:
             raise ValueError(f"unknown cluster type for cluster {cluster.name}")
 
 
-def fetch_current_state_for_cluster(cluster, ocm):
+def fetch_current_state_for_cluster(cluster: ClusterV1, ocm: OCM) -> list[AbstractPool]:
     cluster_type = _classify_cluster_type(cluster)
     if cluster_type == ClusterType.ROSA_HCP:
         return [
@@ -505,14 +509,15 @@ def act(dry_run: bool, diffs: Iterable[PoolHandler], ocm_map: OCMMap) -> None:
         logging.info([diff.action, diff.pool.cluster, diff.pool.id])
         if not dry_run:
             ocm = ocm_map.get(diff.pool.cluster)
-            diff.act(dry_run, ocm)
+            if ocm is not None:
+                diff.act(dry_run, ocm)
 
 
 def _cluster_is_compatible(cluster: ClusterV1) -> bool:
     return cluster.ocm is not None and cluster.machine_pools is not None
 
 
-def run(dry_run: bool):
+def run(dry_run: bool) -> None:
     clusters = get_clusters()
 
     filtered_clusters = [