qontract-reconcile 0.10.1rc884__py3-none-any.whl → 0.10.1rc885__py3-none-any.whl

reconcile/openshift_base.py

@@ -12,9 +12,7 @@ from dataclasses import (
 )
 from typing import (
     Any,
-    Optional,
     Protocol,
-    Union,
     runtime_checkable,
 )
 
@@ -74,7 +72,7 @@ class BaseStateSpec:
 @dataclass
 class CurrentStateSpec(BaseStateSpec):
     kind: str
-    resource_names: Optional[Iterable[str]]
+    resource_names: Iterable[str] | None
 
 
 @dataclass
@@ -84,7 +82,7 @@ class DesiredStateSpec(BaseStateSpec):
     privileged: bool = False
 
 
-StateSpec = Union[CurrentStateSpec, DesiredStateSpec]
+StateSpec = CurrentStateSpec | DesiredStateSpec
 
 
 @runtime_checkable
@@ -114,7 +112,7 @@ class HasOrgAndGithubUsername(Protocol):
 class ClusterMap(Protocol):
     """An OCMap protocol."""
 
-    def get(self, cluster: str, privileged: bool = False) -> Union[OCCli, OCLogMsg]: ...
+    def get(self, cluster: str, privileged: bool = False) -> OCCli | OCLogMsg: ...
 
     def get_cluster(self, cluster: str, privileged: bool = False) -> OCCli: ...
 
@@ -126,9 +124,9 @@ class ClusterMap(Protocol):
 def init_specs_to_fetch(
     ri: ResourceInventory,
     oc_map: ClusterMap,
-    namespaces: Optional[Iterable[Mapping]] = None,
-    clusters: Optional[Iterable[Mapping]] = None,
-    override_managed_types: Optional[Iterable[str]] = None,
+    namespaces: Iterable[Mapping] | None = None,
+    clusters: Iterable[Mapping] | None = None,
+    override_managed_types: Iterable[str] | None = None,
     managed_types_key: str = "managedResourceTypes",
 ) -> list[StateSpec]:
     state_specs: list[StateSpec] = []
@@ -289,7 +287,7 @@ def populate_current_state(
     ri: ResourceInventory,
     integration: str,
     integration_version: str,
-    caller: Optional[str] = None,
+    caller: str | None = None,
 ):
     # if spec.oc is None: - oc can't be none because init_namespace_specs_to_fetch does not create specs if oc is none
     #    return
@@ -319,17 +317,17 @@ def populate_current_state(
 
 
 def fetch_current_state(
-    namespaces: Optional[Iterable[Mapping]] = None,
-    clusters: Optional[Iterable[Mapping]] = None,
-    thread_pool_size: Optional[int] = None,
-    integration: Optional[str] = None,
-    integration_version: Optional[str] = None,
-    override_managed_types: Optional[Iterable[str]] = None,
-    internal: Optional[bool] = None,
+    namespaces: Iterable[Mapping] | None = None,
+    clusters: Iterable[Mapping] | None = None,
+    thread_pool_size: int | None = None,
+    integration: str | None = None,
+    integration_version: str | None = None,
+    override_managed_types: Iterable[str] | None = None,
+    internal: bool | None = None,
     use_jump_host: bool = True,
     init_api_resources: bool = False,
     cluster_admin: bool = False,
-    caller: Optional[str] = None,
+    caller: str | None = None,
 ) -> tuple[ResourceInventory, OC_Map]:
     ri = ResourceInventory()
     settings = queries.get_app_interface_settings()
@@ -568,11 +566,11 @@ class ApplyOptions:
     wait_for_namespace: bool
     recycle_pods: bool
     take_over: bool
-    override_enable_deletion: Optional[bool]
-    caller: Optional[str]
-    all_callers: Optional[Sequence[str]]
-    privileged: Optional[bool]
-    enable_deletion: Optional[bool]
+    override_enable_deletion: bool | None
+    caller: str | None
+    all_callers: Sequence[str] | None
+    privileged: bool | None
+    enable_deletion: bool | None
 
 
 def should_apply(
@@ -887,7 +885,7 @@ def delete_action(
         )
     except StatusCodeError as e:
         ri.register_error()
-        msg = "[{}/{}] {}".format(cluster, namespace, str(e))
+        msg = f"[{cluster}/{namespace}] {str(e)}"
         logging.error(msg)
 
 
@@ -932,7 +930,7 @@ def _realize_resource_data_3way_diff(
     actions: list[dict] = []
 
     if ri.has_error_registered(cluster=cluster):
-        msg = ("[{}] skipping realize_data for " "cluster with errors").format(cluster)
+        msg = f"[{cluster}] skipping realize_data for " "cluster with errors"
         logging.error(msg)
         return actions
 
@@ -1306,8 +1304,8 @@ def aggregate_shared_resources(namespace_info, shared_resources_type):
 
 def determine_user_keys_for_access(
     cluster_name: str,
-    auth_list: Sequence[Union[dict[str, str], HasService]],
-    enforced_user_keys: Optional[list[str]] = None,
+    auth_list: Sequence[dict[str, str] | HasService],
+    enforced_user_keys: list[str] | None = None,
 ) -> list[str]:
     """Return user keys based on enabled cluster authentication methods."""
     AUTH_METHOD_USER_KEY = {
@@ -1353,7 +1351,7 @@ def user_has_cluster_access(
 ) -> bool:
     """Check user has access to cluster."""
     userkeys = determine_user_keys_for_access(cluster.name, cluster.auth)
-    return any((getattr(user, userkey) in cluster_users for userkey in userkeys))
+    return any(getattr(user, userkey) in cluster_users for userkey in userkeys)
 
 
 def get_namespace_type_overrides(namespace: Mapping) -> dict[str, str]:
@@ -1369,7 +1367,7 @@ def get_namespace_type_overrides(namespace: Mapping) -> dict[str, str]:
 
 
 def get_namespace_resource_types(
-    namespace: Mapping, type_overrides: Optional[dict[str, str]] = None
+    namespace: Mapping, type_overrides: dict[str, str] | None = None
 ) -> list[str]:
     """Returns a list with the namespace ResourceTypes, with the overrides in place
 
@@ -1386,7 +1384,7 @@ def get_namespace_resource_types(
 
 
 def get_namespace_resource_names(
-    namespace: Mapping, type_overrides: Optional[dict[str, str]] = None
+    namespace: Mapping, type_overrides: dict[str, str] | None = None
 ) -> dict[str, list[str]]:
     """Returns a list with the namespace ResourceTypeNames, with the overrides in place
 

reconcile/openshift_groups.py

@@ -5,10 +5,7 @@ from collections.abc import (
     Iterable,
     Mapping,
 )
-from typing import (
-    Any,
-    Optional,
-)
+from typing import Any
 
 from sretoolbox.utils import threaded
 
@@ -53,9 +50,7 @@ def get_cluster_state(
     try:
         group = oc.get_group_if_exists(group_name)
     except Exception as e:
-        msg = ("could not get group state for cluster/group combination: {}/{}").format(
-            cluster, group_name
-        )
+        msg = f"could not get group state for cluster/group combination: {cluster}/{group_name}"
         logging.error(msg)
         raise e
     if group is None:
@@ -84,7 +79,7 @@ def create_groups_list(
 
 
 def fetch_current_state(
-    thread_pool_size: int, internal: Optional[bool], use_jump_host: bool
+    thread_pool_size: int, internal: bool | None, use_jump_host: bool
 ) -> tuple[OCMap, list[dict[str, str]], list[str], list[dict[str, str]]]:
     clusters = [c for c in get_clusters() if is_in_shard(c.name)]
     ocm_clusters = [c.name for c in clusters if c.ocm is not None]
@@ -110,7 +105,7 @@ def fetch_current_state(
 
 
 def fetch_desired_state(
-    clusters: list[str], enforced_user_keys: Optional[list[str]] = None
+    clusters: list[str], enforced_user_keys: list[str] | None = None
 ) -> list[dict[str, str]]:
     gqlapi = gql.get_api()
     roles = expiration.filter(query_managed_roles(query_func=gqlapi.query).roles or [])
@@ -145,8 +140,8 @@ def fetch_desired_state(
 def calculate_diff(
     current_state: Iterable[Mapping[str, str]],
     desired_state: Iterable[Mapping[str, str]],
-) -> list[dict[str, Optional[str]]]:
-    diff: list[dict[str, Optional[str]]] = []
+) -> list[dict[str, str | None]]:
+    diff: list[dict[str, str | None]] = []
     users_to_add = subtract_states(
         desired_state, current_state, "add_user_to_group", "create_group"
     )
@@ -164,8 +159,8 @@ def subtract_states(
     subtract_state: Iterable[Mapping[str, str]],
     user_action: str,
     group_action: str,
-) -> list[dict[str, Optional[str]]]:
-    result: list[dict[str, Optional[str]]] = []
+) -> list[dict[str, str | None]]:
+    result: list[dict[str, str | None]] = []
 
     for f_user in from_state:
         found = False
@@ -199,14 +194,14 @@ def subtract_states(
     return result
 
 
-def validate_diffs(diffs: Iterable[Mapping[str, Optional[str]]]) -> None:
+def validate_diffs(diffs: Iterable[Mapping[str, str | None]]) -> None:
     gqlapi = gql.get_api()
     clusters_query = query_managed_groups(query_func=gqlapi.query).clusters or []
 
     desired_combos = [
         {"cluster": diff["cluster"], "group": diff["group"]} for diff in diffs
     ]
-    desired_combos_unique: list[dict[str, Optional[str]]] = []
+    desired_combos_unique: list[dict[str, str | None]] = []
     for combo in desired_combos:
         if combo in desired_combos_unique:
             continue
@@ -232,13 +227,13 @@ def validate_diffs(diffs: Iterable[Mapping[str, Optional[str]]]) -> None:
         raise RuntimeError(msg)
 
 
-def sort_diffs(diff: Mapping[str, Optional[str]]) -> int:
+def sort_diffs(diff: Mapping[str, str | None]) -> int:
     if diff["action"] in {"create_group", "del_user_from_group"}:
         return 1
     return 2
 
 
-def act(diff: Mapping[str, Optional[str]], oc_map: ClusterMap) -> None:
+def act(diff: Mapping[str, str | None], oc_map: ClusterMap) -> None:
     cluster = diff.get("cluster") or ""
     group = diff["group"]
     user = diff["user"]
@@ -257,16 +252,16 @@ def act(diff: Mapping[str, Optional[str]], oc_map: ClusterMap) -> None:
     elif action == "delete_group":
         logging.debug("skipping group deletion")
     else:
-        raise Exception("invalid action: {}".format(action))
+        raise Exception(f"invalid action: {action}")
 
 
 @defer
 def run(
     dry_run: bool,
     thread_pool_size: int = 10,
-    internal: Optional[bool] = None,
+    internal: bool | None = None,
     use_jump_host: bool = True,
-    defer: Optional[Callable] = None,
+    defer: Callable | None = None,
 ) -> None:
     oc_map, current_state, ocm_clusters, groups_list = fetch_current_state(
         thread_pool_size, internal, use_jump_host

reconcile/openshift_namespace_labels.py

@@ -5,11 +5,7 @@ from collections.abc import (
     Generator,
 )
 from threading import Lock
-from typing import (
-    Any,
-    Optional,
-    Union,
-)
+from typing import Any
 
 from kubernetes.client.exceptions import ApiException
 from sretoolbox.utils import threaded
@@ -47,9 +43,9 @@ CURRENT = "current"
 CHANGED = "changed"
 UPDATED_MANAGED = "updated-managed"
 
-Labels = dict[str, Optional[str]]
+Labels = dict[str, str | None]
 LabelKeys = list[str]
-LabelsOrKeys = Union[Labels, LabelKeys]
+LabelsOrKeys = Labels | LabelKeys
 Types = dict[str, LabelsOrKeys]
 
 InternalLabelInventory = dict[str, dict[str, Types]]
@@ -104,8 +100,8 @@ class LabelInventory:
         cluster: str,
         namespace: str,
         type: str,
-        default: Optional[LabelsOrKeys] = None,
-    ) -> Optional[LabelsOrKeys]:
+        default: LabelsOrKeys | None = None,
+    ) -> LabelsOrKeys | None:
         """Get the labels or keys for the given cluster / namespace / type"""
         return self._inv.get(cluster, {}).get(namespace, {}).get(type, default)
 
@@ -293,9 +289,7 @@ def get_managed(inventory: LabelInventory, state: State) -> None:
         inventory.set(cluster=cluster, namespace=ns_name, type=MANAGED, labels=managed)
 
 
-def lookup_namespaces(
-    cluster: str, oc_map: OCMap
-) -> tuple[str, Optional[dict[str, Any]]]:
+def lookup_namespaces(cluster: str, oc_map: OCMap) -> tuple[str, dict[str, Any] | None]:
     """
     Retrieve all namespaces from the given cluster
     """
@@ -410,9 +404,9 @@ class NamespaceLabelError(Exception):
 def run(
     dry_run: bool,
     thread_pool_size: int = 10,
-    internal: Optional[bool] = None,
+    internal: bool | None = None,
     use_jump_host: bool = True,
-    defer: Optional[Callable] = None,
+    defer: Callable | None = None,
     raise_errors: bool = False,
 ) -> None:
     _LOG.debug("Collecting GQL data ...")

reconcile/openshift_namespaces.py

@@ -6,10 +6,7 @@ from collections.abc import (
     Mapping,
     Sequence,
 )
-from typing import (
-    Any,
-    Optional,
-)
+from typing import Any
 
 from sretoolbox.utils import threaded
 
@@ -145,11 +142,11 @@ def check_results(
 def run(
     dry_run: bool,
     thread_pool_size: int = 10,
-    internal: Optional[bool] = None,
+    internal: bool | None = None,
     use_jump_host: bool = True,
-    cluster_name: Optional[Sequence[str]] = None,
-    namespace_name: Optional[Sequence[str]] = None,
-    defer: Optional[Callable] = None,
+    cluster_name: Sequence[str] | None = None,
+    namespace_name: Sequence[str] | None = None,
+    defer: Callable | None = None,
 ) -> None:
     all_namespaces = get_namespaces_minimal()
     shard_namespaces, duplicates = get_shard_namespaces(all_namespaces)

reconcile/openshift_network_policies.py

@@ -94,12 +94,10 @@ def fetch_desired_state(namespaces, ri, oc_map):
             source_cluster = source_namespace_info["cluster"]["name"]
             if cluster != source_cluster:
                 ri.register_error()
-                msg = ("[{}/{}] Network Policy from cluster '{}' not allowed.").format(
-                    cluster, namespace, source_cluster
-                )
+                msg = f"[{cluster}/{namespace}] Network Policy from cluster '{source_cluster}' not allowed."
                 logging.error(msg)
                 continue
-            resource_name = "allow-from-{}-namespace".format(source_namespace)
+            resource_name = f"allow-from-{source_namespace}-namespace"
             oc_resource = construct_oc_resource(resource_name, source_namespace)
             ri.add_desired(
                 cluster,

reconcile/openshift_resources_base.py

@@ -20,9 +20,7 @@ from textwrap import indent
 from threading import Lock
 from typing import (
     Any,
-    Optional,
     Protocol,
-    Tuple,
 )
 from unittest.mock import DEFAULT, patch
 
@@ -479,9 +477,7 @@ def fetch_provider_route(
             tls[k] = v
             continue
 
-        msg = "Route secret '{}' key '{}' not in valid keys {}".format(
-            tls_path, k, valid_keys
-        )
+        msg = f"Route secret '{tls_path}' key '{k}' not in valid keys {valid_keys}"
         _locked_info_log(msg)
 
     host = openshift_resource.body["spec"].get("host")
@@ -504,7 +500,7 @@ def fetch_openshift_resource(
     provider = resource["provider"]
     if provider == "resource":
         path = resource["resource"]["path"]
-        _locked_debug_log("Processing {}: {}".format(provider, path))
+        _locked_debug_log(f"Processing {provider}: {path}")
         validate_json = resource.get("validate_json") or False
         add_path_to_prom_rules = resource.get("add_path_to_prom_rules", True)
         validate_alertmanager_config = (
@@ -524,7 +520,7 @@ def fetch_openshift_resource(
         )
     elif provider == "resource-template":
         path = resource["resource"]["path"]
-        _locked_debug_log("Processing {}: {}".format(provider, path))
+        _locked_debug_log(f"Processing {provider}: {path}")
         add_path_to_prom_rules = resource.get("add_path_to_prom_rules", True)
         validate_alertmanager_config = (
             resource.get("validate_alertmanager_config") or False
@@ -557,12 +553,12 @@ def fetch_openshift_resource(
                 settings=settings,
             )
         except Exception as e:
-            msg = "could not render template at path {}\n{}".format(path, e)
+            msg = f"could not render template at path {path}\n{e}"
             raise ResourceTemplateRenderError(msg)
     elif provider == "vault-secret":
         path = resource["path"]
         version = resource["version"]
-        _locked_debug_log("Processing {}: {} - {}".format(provider, path, version))
+        _locked_debug_log(f"Processing {provider}: {path} - {version}")
         rn = resource["name"]
         name = path.split("/")[-1] if rn is None else rn
         rl = resource["labels"]
@@ -595,7 +591,7 @@ def fetch_openshift_resource(
             raise FetchSecretError(e)
     elif provider == "route":
         path = resource["resource"]["path"]
-        _locked_debug_log("Processing {}: {}".format(provider, path))
+        _locked_debug_log(f"Processing {provider}: {path}")
         tls_path = resource["vault_tls_secret_path"]
         tls_version = resource["vault_tls_secret_version"]
         openshift_resource = fetch_provider_route(
@@ -603,7 +599,7 @@ def fetch_openshift_resource(
         )
     elif provider == "prometheus-rule":
         path = resource["resource"]["path"]
-        _locked_debug_log("Processing {}: {}".format(provider, path))
+        _locked_debug_log(f"Processing {provider}: {path}")
         add_path_to_prom_rules = resource.get("add_path_to_prom_rules", True)
         tv = {}
         if resource["variables"]:
@@ -631,7 +627,7 @@ def fetch_openshift_resource(
                 settings=settings,
             )
         except Exception as e:
-            msg = "could not render template at path {}\n{}".format(path, e)
+            msg = f"could not render template at path {path}\n{e}"
             raise ResourceTemplateRenderError(msg)
 
     else:
@@ -684,7 +680,7 @@ def fetch_desired_state(
         UnknownProviderError,
     ) as e:
         ri.register_error()
-        msg = "[{}/{}] {}".format(cluster, namespace, str(e))
+        msg = f"[{cluster}/{namespace}] {str(e)}"
         _locked_error_log(msg)
         return
 
@@ -702,9 +698,7 @@ def fetch_desired_state(
         # combination was not initialized, meaning that it shouldn't be
         # managed. But someone is trying to add it via app-interface
         ri.register_error()
-        msg = "[{}/{}] unknown kind: {}. hint: is it missing from managedResourceTypes?".format(
-            cluster, namespace, openshift_resource.kind
-        )
+        msg = f"[{cluster}/{namespace}] unknown kind: {openshift_resource.kind}. hint: is it missing from managedResourceTypes?"
         _locked_error_log(msg)
         return
     except ResourceKeyExistsError:
@@ -712,18 +706,14 @@ def fetch_desired_state(
         # a desired resource with the same name and
         # the same type was already added previously
         ri.register_error()
-        msg = ("[{}/{}] desired item already exists: {}/{}.").format(
-            cluster, namespace, openshift_resource.kind, openshift_resource.name
-        )
+        msg = f"[{cluster}/{namespace}] desired item already exists: {openshift_resource.kind}/{openshift_resource.name}."
         _locked_error_log(msg)
         return
     except ResourceNotManagedError:
         # This is failing because the resource name is
         # not in the list of resource names that are managed
         ri.register_error()
-        msg = "[{}/{}] desired item is not managed: {}/{}.".format(
-            cluster, namespace, openshift_resource.kind, openshift_resource.name
-        )
+        msg = f"[{cluster}/{namespace}] desired item is not managed: {openshift_resource.kind}/{openshift_resource.name}."
         _locked_error_log(msg)
         return
 
@@ -1000,7 +990,7 @@ class CheckClusterScopedResourceNames:
 @dataclass
 class CheckClusterScopedResourceDuplicates:
     oc_map: OC_Map
-    all_namespaces: Optional[Iterable[Mapping]] = None
+    all_namespaces: Iterable[Mapping] | None = None
 
     def check(self) -> list[Exception]:
         errors: list[Exception] = []
@@ -1022,13 +1012,13 @@ class CheckClusterScopedResourceDuplicates:
 
     def _find_resource_duplicates(
         self, cluster_cs_resources: dict[str, dict[str, dict[str, list[str]]]]
-    ) -> list[Tuple[str, str, str, list[str]]]:
+    ) -> list[tuple[str, str, str, list[str]]]:
         # ) -> dict[Tuple[str, str, str], list[str]]:
         """Finds cluster resource duplicates by kind/name.
         :param cluster_cs_resources
         :return: duplicates as [(cluster, kind, name, [namespaces])]
         """
-        duplicates: list[Tuple[str, str, str, list[str]]] = []
+        duplicates: list[tuple[str, str, str, list[str]]] = []
 
         for cluster, cluster_resources in cluster_cs_resources.items():
             _kind_name: dict[str, dict[str, list[str]]] = {}
@@ -1048,7 +1038,7 @@ def check_cluster_scoped_resources(
     oc_map: OC_Map,
     ri: ResourceInventory,
     namespaces: Iterable[Mapping[str, Any]],
-    all_namespaces: Optional[Iterable[Mapping[str, Any]]] = None,
+    all_namespaces: Iterable[Mapping[str, Any]] | None = None,
 ) -> bool:
     checks = [
         CheckClusterScopedResourceNames(oc_map, ri, namespaces),
@@ -1069,7 +1059,7 @@ def check_cluster_scoped_resources(
 def get_cluster_scoped_resources(
     oc_map: OC_Map,
     clusters: Iterable[str],
-    namespaces: Optional[Iterable[Mapping[str, Any]]] = None,
+    namespaces: Iterable[Mapping[str, Any]] | None = None,
     thread_pool_size: int = 10,
 ) -> dict[str, dict[str, dict[str, list[str]]]]:
     """Returns cluster scoped resources for a list of clusters
@@ -1106,7 +1096,7 @@ def get_cluster_scoped_resources(
 def _get_namespace_cluster_scoped_resources(
     namespace: Mapping,
     oc_map: OC_Map,
-) -> Tuple[str, str, dict[str, dict[str, Any]]]:
+) -> tuple[str, str, dict[str, dict[str, Any]]]:
     """Returns all non-namespaced resources defined in a namespace manifest.
 
     :param namespace: the namespace dict
@@ -1125,7 +1115,7 @@ def _get_namespace_cluster_scoped_resources(
 
 
 def early_exit_desired_state(
-    providers: list[str], resource_schema_filter: Optional[str] = None
+    providers: list[str], resource_schema_filter: str | None = None
 ) -> dict[str, Any]:
     settings = queries.get_secret_reader_settings()
     namespaces, _ = get_namespaces(

reconcile/openshift_saas_deploy.py

@@ -3,7 +3,6 @@ import logging
 import os
 import sys
 from collections.abc import Callable
-from typing import Optional
 
 import reconcile.openshift_base as ob
 from reconcile import (
@@ -68,9 +67,9 @@ def slack_notify(
     ri: ResourceInventory,
     console_url: str,
     in_progress: bool,
-    trigger_integration: Optional[str] = None,
-    trigger_reason: Optional[str] = None,
-    skip_successful_notifications: Optional[bool] = False,
+    trigger_integration: str | None = None,
+    trigger_reason: str | None = None,
+    skip_successful_notifications: bool | None = False,
 ) -> None:
     success = not ri.has_error_registered()
     # if the deployment doesn't want any notifications for successful
@@ -112,12 +111,12 @@ def run(
     thread_pool_size: int = 10,
     io_dir: str = "throughput/",
     use_jump_host: bool = True,
-    saas_file_name: Optional[str] = None,
-    env_name: Optional[str] = None,
-    trigger_integration: Optional[str] = None,
-    trigger_reason: Optional[str] = None,
-    saas_file_list: Optional[SaasFileList] = None,
-    defer: Optional[Callable] = None,
+    saas_file_name: str | None = None,
+    env_name: str | None = None,
+    trigger_integration: str | None = None,
+    trigger_reason: str | None = None,
+    saas_file_list: SaasFileList | None = None,
+    defer: Callable | None = None,
 ) -> None:
     vault_settings = get_app_interface_vault_settings()
     secret_reader = create_secret_reader(use_vault=vault_settings.vault)

reconcile/openshift_saas_deploy_change_tester.py

@@ -1,10 +1,7 @@
 import logging
 import sys
 from collections.abc import Iterable
-from typing import (
-    Any,
-    Optional,
-)
+from typing import Any
 
 from pydantic import BaseModel
 from sretoolbox.utils import threaded
@@ -37,7 +34,7 @@ class Definition(BaseModel):
 class State(BaseModel):
     saas_file_path: str
     saas_file_name: str
-    saas_file_deploy_resources: Optional[DeployResourcesV1]
+    saas_file_deploy_resources: DeployResourcesV1 | None
     resource_template_name: str
     cluster: str
     namespace: str
@@ -47,10 +44,10 @@ class State(BaseModel):
     parameters: dict[str, Any]
     secret_parameters: dict[str, VaultSecret]
     saas_file_definitions: Definition
-    upstream: Optional[SaasResourceTemplateTargetUpstreamV1]
-    disable: Optional[bool]
-    delete: Optional[bool]
-    target_path: Optional[str]
+    upstream: SaasResourceTemplateTargetUpstreamV1 | None
+    disable: bool | None
+    delete: bool | None
+    target_path: str | None
 
 
 def osd_run_wrapper(
@@ -58,7 +55,7 @@ def osd_run_wrapper(
     dry_run: bool,
     available_thread_pool_size: int,
     use_jump_host: bool,
-    saas_file_list: Optional[SaasFileList],
+    saas_file_list: SaasFileList | None,
 ) -> int:
     saas_file_name, env_name = spec
     exit_code = 0

reconcile/openshift_saas_deploy_trigger_base.py

@@ -1,10 +1,7 @@
 import logging
 from collections.abc import Callable
 from threading import Lock
-from typing import (
-    Any,
-    Optional,
-)
+from typing import Any
 
 from sretoolbox.utils import threaded
 
@@ -63,7 +60,7 @@ def run(
     internal: bool,
     use_jump_host: bool,
     include_trigger_trace: bool,
-    defer: Optional[Callable] = None,
+    defer: Callable | None = None,
 ) -> bool:
     """Run trigger integration
 
@@ -327,13 +324,13 @@ def _construct_tekton_trigger_resource(
     saas_file_name: str,
     env_name: str,
     tkn_pipeline_name: str,
-    timeout: Optional[str],
+    timeout: str | None,
     tkn_cluster_console_url: str,
     tkn_namespace_name: str,
     integration: str,
     integration_version: str,
     include_trigger_trace: bool,
-    reason: Optional[str],
+    reason: str | None,
 ) -> tuple[OR, str]:
     """Construct a resource (PipelineRun) to trigger a deployment via Tekton.