qontract-reconcile 0.10.0__py3-none-any.whl → 0.10.1.dev1203__py3-none-any.whl

reconcile/typed_queries/cost_report/cost_namespaces.py

@@ -0,0 +1,43 @@
+from pydantic import BaseModel
+
+from reconcile.gql_definitions.cost_report.cost_namespaces import query
+from reconcile.utils.gql import GqlApi
+
+
+class CostNamespaceLabels(BaseModel, frozen=True):
+    insights_cost_management_optimizations: str | None = None
+
+
+class CostNamespace(BaseModel, frozen=True):
+    name: str
+    labels: CostNamespaceLabels
+    app_name: str
+    cluster_name: str
+    cluster_external_id: str | None
+
+
+def get_cost_namespaces(
+    gql_api: GqlApi,
+) -> list[CostNamespace]:
+    variables = {
+        "filter": {
+            "cluster": {
+                "filter": {
+                    "enableCostReport": True,
+                },
+            },
+        },
+    }
+    namespaces = query(gql_api.query, variables=variables).namespaces or []
+    return [
+        CostNamespace(
+            name=namespace.name,
+            labels=CostNamespaceLabels.parse_obj(namespace.labels or {}),
+            app_name=namespace.app.name,
+            cluster_name=namespace.cluster.name,
+            cluster_external_id=namespace.cluster.spec.external_id
+            if namespace.cluster.spec
+            else None,
+        )
+        for namespace in namespaces
+    ]

reconcile/typed_queries/cost_report/settings.py

@@ -0,0 +1,15 @@
+from reconcile.gql_definitions.cost_report.settings import CostReportSettingsV1, query
+from reconcile.utils.exceptions import AppInterfaceSettingsError
+from reconcile.utils.gql import GqlApi
+
+
+def get_cost_report_settings(
+    gql_api: GqlApi,
+) -> CostReportSettingsV1:
+    data = query(gql_api.query)
+    if not data.settings:
+        raise AppInterfaceSettingsError("No settings configured")
+    cost_report_settings = data.settings[0].cost_report
+    if cost_report_settings is None:
+        raise AppInterfaceSettingsError("No cost report configured")
+    return cost_report_settings

reconcile/typed_queries/dynatrace.py

@@ -0,0 +1,10 @@
+from reconcile.gql_definitions.dynatrace_token_provider.dynatrace_bootstrap_tokens import (
+    DynatraceEnvironmentV1,
+    query,
+)
+from reconcile.utils import gql
+
+
+def get_dynatrace_environments() -> list[DynatraceEnvironmentV1]:
+    data = query(gql.get_api().query)
+    return list(data.environments or [])

reconcile/typed_queries/dynatrace_environments.py

@@ -0,0 +1,14 @@
+from reconcile.gql_definitions.dynatrace_token_provider.dynatrace_bootstrap_tokens import (
+    DynatraceEnvironmentV1,
+    query,
+)
+from reconcile.utils import gql
+from reconcile.utils.gql import GqlApi
+
+
+def get_dynatrace_environments(
+    api: GqlApi | None = None,
+) -> list[DynatraceEnvironmentV1]:
+    api = api if api else gql.get_api()
+    data = query(api.query)
+    return list(data.environments or [])

reconcile/typed_queries/dynatrace_token_provider_token_specs.py

@@ -0,0 +1,14 @@
+from reconcile.gql_definitions.dynatrace_token_provider.token_specs import (
+    DynatraceTokenProviderTokenSpecV1,
+    query,
+)
+from reconcile.utils import gql
+from reconcile.utils.gql import GqlApi
+
+
+def get_dynatrace_token_provider_token_specs(
+    api: GqlApi | None = None,
+) -> list[DynatraceTokenProviderTokenSpecV1]:
+    api = api if api else gql.get_api()
+    data = query(api.query)
+    return list(data.token_specs or [])

reconcile/typed_queries/external_resources.py

@@ -0,0 +1,46 @@
+from collections.abc import Callable
+
+from reconcile.gql_definitions.external_resources.external_resources_modules import (
+    ExternalResourcesModuleV1,
+)
+from reconcile.gql_definitions.external_resources.external_resources_modules import (
+    query as query_modules,
+)
+from reconcile.gql_definitions.external_resources.external_resources_namespaces import (
+    NamespaceV1,
+)
+from reconcile.gql_definitions.external_resources.external_resources_namespaces import (
+    query as query_namespaces,
+)
+from reconcile.gql_definitions.external_resources.external_resources_settings import (
+    ExternalResourcesSettingsV1,
+)
+from reconcile.gql_definitions.external_resources.external_resources_settings import (
+    query as query_settings,
+)
+from reconcile.utils import gql
+
+
+def get_namespaces(query_func: Callable | None = None) -> list[NamespaceV1]:
+    if not query_func:
+        query_func = gql.get_api().query
+    data = query_namespaces(query_func=query_func)
+    return list(data.namespaces or [])
+
+
+def get_settings(query_func: Callable | None = None) -> ExternalResourcesSettingsV1:
+    if not query_func:
+        query_func = gql.get_api().query
+    data = query_settings(query_func=query_func)
+    if not data.settings:
+        raise ValueError("No external resources settings found.")
+    return data.settings[0]
+
+
+def get_modules(
+    query_func: Callable | None = None,
+) -> list[ExternalResourcesModuleV1]:
+    if not query_func:
+        query_func = gql.get_api().query
+    data = query_modules(query_func=query_func)
+    return list(data.modules or [])

reconcile/typed_queries/get_state_aws_account.py

@@ -0,0 +1,20 @@
+from collections.abc import Callable
+
+from reconcile.gql_definitions.common.state_aws_account import (
+    AWSAccountV1,
+    query,
+)
+from reconcile.utils import gql
+
+
+def get_state_aws_account(
+    name: str, query_func: Callable | None = None
+) -> AWSAccountV1 | None:
+    if not query_func:
+        query_func = gql.get_api().query
+    if (
+        accounts := query(query_func=query_func, variables={"name": name}).accounts
+        or []
+    ):
+        return accounts[0]
+    return None

reconcile/typed_queries/glitchtip.py

@@ -0,0 +1,10 @@
+from reconcile.gql_definitions.glitchtip.glitchtip_instance import (
+    GlitchtipInstanceV1,
+    query,
+)
+from reconcile.utils import gql
+
+
+def get_glitchtip_instances() -> list[GlitchtipInstanceV1]:
+    data = query(gql.get_api().query)
+    return list(data.instances or [])

reconcile/typed_queries/jenkins.py

@@ -0,0 +1,25 @@
+from reconcile.gql_definitions.jenkins_configs.jenkins_configs import (
+    JenkinsConfigV1,
+)
+from reconcile.gql_definitions.jenkins_configs.jenkins_configs import (
+    query as jenkins_configs_query,
+)
+from reconcile.gql_definitions.jenkins_configs.jenkins_instances import (
+    JenkinsInstanceV1,
+)
+from reconcile.gql_definitions.jenkins_configs.jenkins_instances import (
+    query as jenkins_instances_query,
+)
+from reconcile.utils import gql
+
+
+def get_jenkins_instances() -> list[JenkinsInstanceV1]:
+    gqlapi = gql.get_api()
+    data = jenkins_instances_query(gqlapi.query)
+    return list(data.instances or [])
+
+
+def get_jenkins_configs() -> list[JenkinsConfigV1]:
+    gqlapi = gql.get_api()
+    data = jenkins_configs_query(gqlapi.query)
+    return list(data.jenkins_configs or [])

reconcile/typed_queries/jira.py

@@ -0,0 +1,7 @@
+from reconcile.gql_definitions.jira.jira_servers import JiraServerV1, query
+from reconcile.utils import gql
+
+
+def get_jira_servers() -> list[JiraServerV1]:
+    data = query(gql.get_api().query)
+    return list(data.jira_servers or [])

reconcile/typed_queries/jira_settings.py

@@ -0,0 +1,16 @@
+from reconcile.gql_definitions.common.jira_settings import (
+    AppInterfaceSettingsV1,
+    query,
+)
+from reconcile.utils.exceptions import AppInterfaceSettingsError
+from reconcile.utils.gql import GqlApi
+
+
+def get_jira_settings(
+    gql_api: GqlApi,
+) -> AppInterfaceSettingsV1:
+    """Returns App Interface Settings and raises err if none are found"""
+    data = query(query_func=gql_api.query)
+    if data.jira_settings and len(data.jira_settings) == 1:
+        return data.jira_settings[0]
+    raise AppInterfaceSettingsError("jira settings not uniquely defined.")

reconcile/typed_queries/jiralert_settings.py

@@ -0,0 +1,22 @@
+from collections.abc import Callable
+
+from reconcile.gql_definitions.common.jiralert_settings import (
+    JiralertSettingsV1,
+    query,
+)
+from reconcile.utils import gql
+from reconcile.utils.exceptions import AppInterfaceSettingsError
+
+
+def get_jiralert_settings(
+    query_func: Callable | None = None,
+) -> JiralertSettingsV1:
+    """Returns App Interface Settings and raises err if none are found"""
+    if not query_func:
+        query_func = gql.get_api().query
+    data = query(query_func)
+    if data.settings and len(data.settings) == 1:
+        if data.settings[0].jiralert:
+            return data.settings[0].jiralert
+        return JiralertSettingsV1(defaultIssueType="Task", defaultReopenState="To Do")
+    raise AppInterfaceSettingsError("jira settings not uniquely defined.")

reconcile/typed_queries/ocm.py

@@ -0,0 +1,8 @@
+from reconcile.gql_definitions.common.ocm_environments import query
+from reconcile.gql_definitions.fragments.ocm_environment import OCMEnvironment
+from reconcile.utils import gql
+
+
+def get_ocm_environments() -> list[OCMEnvironment]:
+    data = query(gql.get_api().query)
+    return list(data.environments or [])

reconcile/typed_queries/pagerduty_instances.py

@@ -1,22 +1,17 @@
 from collections.abc import Callable
-from typing import Optional
 
 from reconcile.gql_definitions.common.pagerduty_instances import (
     PagerDutyInstanceV1,
     query,
 )
 from reconcile.utils import gql
-from reconcile.utils.exceptions import AppInterfaceSettingsError
 
 
 def get_pagerduty_instances(
-    query_func: Optional[Callable],
+    query_func: Callable | None,
 ) -> list[PagerDutyInstanceV1]:
     """Return all pagerduty instances from app-interface."""
     if not query_func:
         gqlapi = gql.get_api()
         query_func = gqlapi.query
-    pagerduty_instances = query(query_func=query_func).pagerduty_instances
-    if not pagerduty_instances:
-        raise AppInterfaceSettingsError("no pagerduty instance(s) configured")
-    return pagerduty_instances
+    return query(query_func=query_func).pagerduty_instances or []

reconcile/typed_queries/quay.py

@@ -0,0 +1,23 @@
+from reconcile.gql_definitions.common.quay_instances import (
+    QuayInstanceV1,
+)
+from reconcile.gql_definitions.common.quay_instances import (
+    query as quay_instances_query,
+)
+from reconcile.gql_definitions.common.quay_orgs import (
+    QuayOrgV1,
+)
+from reconcile.gql_definitions.common.quay_orgs import (
+    query as quay_orgs_query,
+)
+from reconcile.utils import gql
+
+
+def get_quay_instances() -> list[QuayInstanceV1]:
+    data = quay_instances_query(gql.get_api().query)
+    return list(data.instances or [])
+
+
+def get_quay_orgs() -> list[QuayOrgV1]:
+    data = quay_orgs_query(gql.get_api().query)
+    return list(data.orgs or [])

reconcile/typed_queries/repos.py

@@ -1,17 +1,29 @@
 from collections.abc import Callable
-from typing import Optional
 
-from reconcile.gql_definitions.common.app_code_component_repos import query
+from reconcile.gql_definitions.common.app_code_component_repos import (
+    AppCodeComponentsV1,
+    query,
+)
 from reconcile.utils import gql
 
 
-def get_repos(
+def get_code_components(
     server: str = "",
-    query_func: Optional[Callable] = None,
-) -> list[str]:
+    query_func: Callable | None = None,
+) -> list[AppCodeComponentsV1]:
     if not query_func:
         query_func = gql.get_api().query
-    repos: list[str] = []
+    code_components: list[AppCodeComponentsV1] = []
     for app in query(query_func).apps or []:
-        repos += [c.url for c in app.code_components or [] if c.url.startswith(server)]
-    return repos
+        code_components += [
+            c for c in app.code_components or [] if c.url.startswith(server)
+        ]
+    return code_components
+
+
+def get_repos(
+    server: str = "",
+    query_func: Callable | None = None,
+) -> list[str]:
+    code_components = get_code_components(server=server, query_func=query_func)
+    return [c.url for c in code_components]

reconcile/typed_queries/reserved_networks.py

@@ -0,0 +1,12 @@
+from reconcile.gql_definitions.common.reserved_networks import (
+    NetworkV1,
+    query,
+)
+from reconcile.utils import gql
+from reconcile.utils.gql import GqlApi
+
+
+def get_networks(gql_api: GqlApi | None = None) -> list[NetworkV1]:
+    api = gql_api if gql_api else gql.get_api()
+    data = query(query_func=api.query)
+    return list(data.networks or [])