qontract-reconcile 0.10.2.dev135__py3-none-any.whl → 0.10.2.dev136__py3-none-any.whl

reconcile/gitlab_fork_compliance.py

@@ -1,5 +1,6 @@
 import logging
 import sys
+from typing import Any, Self
 
 from gitlab import GitlabGetError
 from gitlab.const import MAINTAINER_ACCESS
@@ -36,7 +37,7 @@ class GitlabForkCompliance:
     ERR_NOT_A_MEMBER = 0x0002
     ERR_NOT_A_MAINTAINER = 0x0004
 
-    def __init__(self, project_id, mr_id, maintainers_group):
+    def __init__(self, project_id: str, mr_id: str, maintainers_group: str) -> None:
         self.exit_code = self.OK
 
         self.maintainers_group = maintainers_group
@@ -50,15 +51,15 @@ class GitlabForkCompliance:
         )
         self.mr = self.gl_cli.get_merge_request(mr_id)
 
-    def __enter__(self):
+    def __enter__(self) -> Self:
         return self
 
-    def __exit__(self, *exc):
+    def __exit__(self, *exc: Any) -> None:
         self.gl_cli.cleanup()
         if hasattr(self, "src") and self.src is not None:
             self.src.cleanup()
 
-    def run(self):
+    def run(self) -> None:
         self.exit_code |= self.check_branch()
         self.exit_code |= self.check_bot_access()
         if self.exit_code:
@@ -86,7 +87,7 @@ class GitlabForkCompliance:
 
         sys.exit(self.exit_code)
 
-    def check_branch(self):
+    def check_branch(self) -> int:
         # The Merge Request can use the 'master' source branch
         if self.mr.source_branch == "master":
             self.handle_error("source branch can not be master", MSG_BRANCH)
@@ -94,7 +95,7 @@ class GitlabForkCompliance:
 
         return self.OK
 
-    def check_bot_access(self):
+    def check_bot_access(self) -> int:
         try:
             self.src = GitLabApi(
                 self.instance,
@@ -113,7 +114,7 @@ class GitlabForkCompliance:
 
         return self.OK
 
-    def handle_error(self, log_msg, mr_msg):
+    def handle_error(self, log_msg: str, mr_msg: str) -> None:
         LOG.error([log_msg.format(bot=self.gl_cli.user.username)])
         self.gl_cli.add_label_to_merge_request(self.mr, BLOCKED_BOT_ACCESS)
         comment = mr_msg.format(
@@ -124,6 +125,6 @@ class GitlabForkCompliance:
         self.mr.notes.create({"body": comment})
 
 
-def run(dry_run, project_id, mr_id, maintainers_group):
+def run(dry_run: bool, project_id: str, mr_id: str, maintainers_group: str) -> None:
     with GitlabForkCompliance(project_id, mr_id, maintainers_group) as gfc:
         gfc.run()

reconcile/gitlab_labeler.py

@@ -122,7 +122,7 @@ def guess_labels(
     return guesses
 
 
-def run(dry_run, gitlab_project_id=None, gitlab_merge_request_id=None) -> None:
+def run(dry_run: bool, gitlab_project_id: str, gitlab_merge_request_id: str) -> None:
     instance = queries.get_gitlab_instance()
     settings = queries.get_app_interface_settings()
     with GitLabApi(instance, project_id=gitlab_project_id, settings=settings) as gl:

reconcile/gitlab_mr_sqs_consumer.py

@@ -5,6 +5,7 @@ SQS Consumer to create Gitlab merge requests.
 import json
 import logging
 import sys
+from collections.abc import Callable
 
 from reconcile import queries
 from reconcile.utils import mr
@@ -17,18 +18,20 @@ QONTRACT_INTEGRATION = "gitlab-mr-sqs-consumer"
 
 
 @defer
-def run(dry_run, gitlab_project_id, defer=None):
+def run(dry_run: str, gitlab_project_id: str, defer: Callable | None = None) -> None:
     secret_reader = SecretReader(queries.get_secret_reader_settings())
 
     accounts = queries.get_queue_aws_accounts()
     sqs_cli = SQSGateway(accounts, secret_reader)
-    defer(sqs_cli.cleanup)
+    if defer:
+        defer(sqs_cli.cleanup)
 
     instance = queries.get_gitlab_instance()
     gitlab_cli = GitLabApi(
         instance, project_id=gitlab_project_id, secret_reader=secret_reader
     )
-    defer(gitlab_cli.cleanup)
+    if defer:
+        defer(gitlab_cli.cleanup)
 
     errors_occured = False
     while True:

reconcile/gitlab_owners.py

@@ -1,6 +1,9 @@
 import logging
+from collections.abc import Callable, Mapping
+from typing import Any
 
 from dateutil import parser as dateparser
+from gitlab.v4.objects import ProjectMergeRequest
 from sretoolbox.utils import threaded
 
 from reconcile import queries
@@ -31,7 +34,14 @@ class MRApproval:
     between the approval messages the the project owners.
     """
 
-    def __init__(self, gitlab_client, merge_request, owners, dry_run, persistent_lgtm):
+    def __init__(
+        self,
+        gitlab_client: GitLabApi,
+        merge_request: ProjectMergeRequest,
+        owners: RepoOwners,
+        dry_run: bool,
+        persistent_lgtm: bool,
+    ) -> None:
         self.gitlab = gitlab_client
         self.mr = merge_request
         self.owners = owners
@@ -45,7 +55,7 @@ class MRApproval:
             top_commit = next(commits)
             self.top_commit_created_at = dateparser.parse(top_commit.created_at)
 
-    def get_change_owners_map(self):
+    def get_change_owners_map(self) -> dict[str, dict[str, list[str]]]:
         """
         Maps each change path to the list of owners that can approve
         that change.
@@ -71,7 +81,7 @@ class MRApproval:
             }
         return change_owners_map
 
-    def get_lgtms(self):
+    def get_lgtms(self) -> list[str]:
         """
         Collects the usernames of all the '/lgtm' comments.
         """
@@ -101,8 +111,8 @@ class MRApproval:
                 members.update(m.username for m in self.gitlab.get_group_members(group))
         return members.union(owners)
 
-    def get_approval_status(self):
-        approval_status = {"approved": False, "report": None}
+    def get_approval_status(self) -> dict[str, Any]:
+        approval_status: dict[str, Any] = {"approved": False, "report": None}
 
         try:
             change_owners_map = self.get_change_owners_map()
@@ -114,7 +124,7 @@ class MRApproval:
         if not change_owners_map:
             return approval_status
 
-        report = {}
+        report: dict[str, Any] = {}
         lgtms = self.get_lgtms()
 
         approval_status["approved"] = True
@@ -200,18 +210,18 @@ class MRApproval:
         approval_status["report"] = formatted_report
         return approval_status
 
-    def has_approval_label(self):
+    def has_approval_label(self) -> bool:
         return APPROVED in self.mr.labels
 
     @staticmethod
-    def format_report(report):
+    def format_report(report: Mapping[str, Any]) -> str:
         """
         Gets a report dictionary and creates the corresponding Markdown
         comment message.
         """
         markdown_report = ""
 
-        closest_approvers = []
+        closest_approvers: list[list[str]] = []
         for owners in report.values():
             new_group = []
 
@@ -323,9 +333,16 @@ class MRApproval:
 
 
 @defer
-def act(repo, dry_run, instance, settings, defer=None):
+def act(
+    repo: Mapping,
+    dry_run: bool,
+    instance: Mapping,
+    settings: Mapping,
+    defer: Callable | None = None,
+) -> None:
     gitlab_cli = GitLabApi(instance, project_url=repo["url"], settings=settings)
-    defer(gitlab_cli.cleanup)
+    if defer:
+        defer(gitlab_cli.cleanup)
     project_owners = RepoOwners(
         git_cli=gitlab_cli, ref=gitlab_cli.project.default_branch
     )
@@ -392,7 +409,7 @@ def act(repo, dry_run, instance, settings, defer=None):
         ])
 
 
-def run(dry_run, thread_pool_size=10):
+def run(dry_run: bool, thread_pool_size: int = 10) -> None:
     instance = queries.get_gitlab_instance()
     settings = queries.get_app_interface_settings()
     repos = queries.get_repos_gitlab_owner(server=instance["url"])

reconcile/gql_definitions/email_sender/apps.py

@@ -0,0 +1,64 @@
+"""
+Generated by qenerate plugin=pydantic_v1. DO NOT MODIFY MANUALLY!
+"""
+from collections.abc import Callable  # noqa: F401 # pylint: disable=W0611
+from datetime import datetime  # noqa: F401 # pylint: disable=W0611
+from enum import Enum  # noqa: F401 # pylint: disable=W0611
+from typing import (  # noqa: F401 # pylint: disable=W0611
+    Any,
+    Optional,
+    Union,
+)
+
+from pydantic import (  # noqa: F401 # pylint: disable=W0611
+    BaseModel,
+    Extra,
+    Field,
+    Json,
+)
+
+from reconcile.gql_definitions.fragments.email_service import EmailServiceOwners
+
+
+DEFINITION = """
+fragment EmailServiceOwners on App_v1 {
+  serviceOwners {
+    email
+  }
+}
+
+query EmailApps {
+  apps: apps_v1 {
+    ...EmailServiceOwners
+  }
+}
+"""
+
+
+class ConfiguredBaseModel(BaseModel):
+    class Config:
+        smart_union=True
+        extra=Extra.forbid
+
+
+class EmailAppsQueryData(ConfiguredBaseModel):
+    apps: Optional[list[EmailServiceOwners]] = Field(..., alias="apps")
+
+
+def query(query_func: Callable, **kwargs: Any) -> EmailAppsQueryData:
+    """
+    This is a convenience function which queries and parses the data into
+    concrete types. It should be compatible with most GQL clients.
+    You do not have to use it to consume the generated data classes.
+    Alternatively, you can also mime and alternate the behavior
+    of this function in the caller.
+
+    Parameters:
+        query_func (Callable): Function which queries your GQL Server
+        kwargs: optional arguments that will be passed to the query function
+
+    Returns:
+        EmailAppsQueryData: queried data parsed into generated classes
+    """
+    raw_data: dict[Any, Any] = query_func(DEFINITION, **kwargs)
+    return EmailAppsQueryData(**raw_data)

reconcile/gql_definitions/email_sender/emails.py

@@ -0,0 +1,133 @@
+"""
+Generated by qenerate plugin=pydantic_v1. DO NOT MODIFY MANUALLY!
+"""
+from collections.abc import Callable  # noqa: F401 # pylint: disable=W0611
+from datetime import datetime  # noqa: F401 # pylint: disable=W0611
+from enum import Enum  # noqa: F401 # pylint: disable=W0611
+from typing import (  # noqa: F401 # pylint: disable=W0611
+    Any,
+    Optional,
+    Union,
+)
+
+from pydantic import (  # noqa: F401 # pylint: disable=W0611
+    BaseModel,
+    Extra,
+    Field,
+    Json,
+)
+
+from reconcile.gql_definitions.fragments.email_service import EmailServiceOwners
+from reconcile.gql_definitions.fragments.email_user import EmailUser
+
+
+DEFINITION = """
+fragment EmailServiceOwners on App_v1 {
+  serviceOwners {
+    email
+  }
+}
+
+fragment EmailUser on User_v1 {
+  org_username
+}
+
+query Emails {
+  emails: app_interface_emails_v1 {
+    name
+    subject
+    to {
+      aliases
+      services {
+        ... EmailServiceOwners
+      }
+      clusters {
+        name
+      }
+      namespaces {
+        name
+      }
+      aws_accounts {
+        accountOwners {
+          email
+        }
+      }
+      roles {
+        users {
+          ... EmailUser
+        }
+      }
+      users {
+        ... EmailUser
+      }
+    }
+    body
+  }
+}
+"""
+
+
+class ConfiguredBaseModel(BaseModel):
+    class Config:
+        smart_union=True
+        extra=Extra.forbid
+
+
+class ClusterV1(ConfiguredBaseModel):
+    name: str = Field(..., alias="name")
+
+
+class NamespaceV1(ConfiguredBaseModel):
+    name: str = Field(..., alias="name")
+
+
+class OwnerV1(ConfiguredBaseModel):
+    email: str = Field(..., alias="email")
+
+
+class AWSAccountV1(ConfiguredBaseModel):
+    account_owners: list[OwnerV1] = Field(..., alias="accountOwners")
+
+
+class RoleV1(ConfiguredBaseModel):
+    users: list[EmailUser] = Field(..., alias="users")
+
+
+class AppInterfaceEmailAudienceV1(ConfiguredBaseModel):
+    aliases: Optional[list[str]] = Field(..., alias="aliases")
+    services: Optional[list[EmailServiceOwners]] = Field(..., alias="services")
+    clusters: Optional[list[ClusterV1]] = Field(..., alias="clusters")
+    namespaces: Optional[list[NamespaceV1]] = Field(..., alias="namespaces")
+    aws_accounts: Optional[list[AWSAccountV1]] = Field(..., alias="aws_accounts")
+    roles: Optional[list[RoleV1]] = Field(..., alias="roles")
+    users: Optional[list[EmailUser]] = Field(..., alias="users")
+
+
+class AppInterfaceEmailV1(ConfiguredBaseModel):
+    name: str = Field(..., alias="name")
+    subject: str = Field(..., alias="subject")
+    q_to: AppInterfaceEmailAudienceV1 = Field(..., alias="to")
+    body: str = Field(..., alias="body")
+
+
+class EmailsQueryData(ConfiguredBaseModel):
+    emails: Optional[list[AppInterfaceEmailV1]] = Field(..., alias="emails")
+
+
+def query(query_func: Callable, **kwargs: Any) -> EmailsQueryData:
+    """
+    This is a convenience function which queries and parses the data into
+    concrete types. It should be compatible with most GQL clients.
+    You do not have to use it to consume the generated data classes.
+    Alternatively, you can also mime and alternate the behavior
+    of this function in the caller.
+
+    Parameters:
+        query_func (Callable): Function which queries your GQL Server
+        kwargs: optional arguments that will be passed to the query function
+
+    Returns:
+        EmailsQueryData: queried data parsed into generated classes
+    """
+    raw_data: dict[Any, Any] = query_func(DEFINITION, **kwargs)
+    return EmailsQueryData(**raw_data)

reconcile/gql_definitions/email_sender/users.py

@@ -0,0 +1,62 @@
+"""
+Generated by qenerate plugin=pydantic_v1. DO NOT MODIFY MANUALLY!
+"""
+from collections.abc import Callable  # noqa: F401 # pylint: disable=W0611
+from datetime import datetime  # noqa: F401 # pylint: disable=W0611
+from enum import Enum  # noqa: F401 # pylint: disable=W0611
+from typing import (  # noqa: F401 # pylint: disable=W0611
+    Any,
+    Optional,
+    Union,
+)
+
+from pydantic import (  # noqa: F401 # pylint: disable=W0611
+    BaseModel,
+    Extra,
+    Field,
+    Json,
+)
+
+from reconcile.gql_definitions.fragments.email_user import EmailUser
+
+
+DEFINITION = """
+fragment EmailUser on User_v1 {
+  org_username
+}
+
+query EmailUsers {
+  users: users_v1 {
+    ... EmailUser
+  }
+}
+"""
+
+
+class ConfiguredBaseModel(BaseModel):
+    class Config:
+        smart_union=True
+        extra=Extra.forbid
+
+
+class EmailUsersQueryData(ConfiguredBaseModel):
+    users: Optional[list[EmailUser]] = Field(..., alias="users")
+
+
+def query(query_func: Callable, **kwargs: Any) -> EmailUsersQueryData:
+    """
+    This is a convenience function which queries and parses the data into
+    concrete types. It should be compatible with most GQL clients.
+    You do not have to use it to consume the generated data classes.
+    Alternatively, you can also mime and alternate the behavior
+    of this function in the caller.
+
+    Parameters:
+        query_func (Callable): Function which queries your GQL Server
+        kwargs: optional arguments that will be passed to the query function
+
+    Returns:
+        EmailUsersQueryData: queried data parsed into generated classes
+    """
+    raw_data: dict[Any, Any] = query_func(DEFINITION, **kwargs)
+    return EmailUsersQueryData(**raw_data)

reconcile/gql_definitions/fragments/email_service.py

@@ -0,0 +1,32 @@
+"""
+Generated by qenerate plugin=pydantic_v1. DO NOT MODIFY MANUALLY!
+"""
+from collections.abc import Callable  # noqa: F401 # pylint: disable=W0611
+from datetime import datetime  # noqa: F401 # pylint: disable=W0611
+from enum import Enum  # noqa: F401 # pylint: disable=W0611
+from typing import (  # noqa: F401 # pylint: disable=W0611
+    Any,
+    Optional,
+    Union,
+)
+
+from pydantic import (  # noqa: F401 # pylint: disable=W0611
+    BaseModel,
+    Extra,
+    Field,
+    Json,
+)
+
+
+class ConfiguredBaseModel(BaseModel):
+    class Config:
+        smart_union=True
+        extra=Extra.forbid
+
+
+class OwnerV1(ConfiguredBaseModel):
+    email: str = Field(..., alias="email")
+
+
+class EmailServiceOwners(ConfiguredBaseModel):
+    service_owners: Optional[list[OwnerV1]] = Field(..., alias="serviceOwners")

reconcile/gql_definitions/fragments/email_user.py

@@ -0,0 +1,28 @@
+"""
+Generated by qenerate plugin=pydantic_v1. DO NOT MODIFY MANUALLY!
+"""
+from collections.abc import Callable  # noqa: F401 # pylint: disable=W0611
+from datetime import datetime  # noqa: F401 # pylint: disable=W0611
+from enum import Enum  # noqa: F401 # pylint: disable=W0611
+from typing import (  # noqa: F401 # pylint: disable=W0611
+    Any,
+    Optional,
+    Union,
+)
+
+from pydantic import (  # noqa: F401 # pylint: disable=W0611
+    BaseModel,
+    Extra,
+    Field,
+    Json,
+)
+
+
+class ConfiguredBaseModel(BaseModel):
+    class Config:
+        smart_union=True
+        extra=Extra.forbid
+
+
+class EmailUser(ConfiguredBaseModel):
+    org_username: str = Field(..., alias="org_username")

reconcile/queries.py

@@ -124,50 +124,6 @@ def get_app_interface_settings():
     return None
 
 
-APP_INTERFACE_EMAILS_QUERY = """
-{
-  emails: app_interface_emails_v1 {
-    name
-    subject
-    to {
-      aliases
-      services {
-        serviceOwners {
-          email
-        }
-      }
-      clusters {
-        name
-      }
-      namespaces {
-        name
-      }
-      aws_accounts {
-        accountOwners {
-          email
-        }
-      }
-      roles {
-        users {
-          org_username
-        }
-      }
-      users {
-        org_username
-      }
-    }
-    body
-  }
-}
-"""
-
-
-def get_app_interface_emails():
-    """Returns Email resources defined in app-interface"""
-    gqlapi = gql.get_api()
-    return gqlapi.query(APP_INTERFACE_EMAILS_QUERY)["emails"]
-
-
 CREDENTIALS_REQUESTS_QUERY = """
 {
   credentials_requests: credentials_requests_v1 {

reconcile/utils/jinja2/utils.py

@@ -116,8 +116,10 @@ def lookup_github_file_content(
         )
 
     gh = init_github()
-    c = gh.get_repo(repo).get_contents(path, ref).decoded_content
-    return c.decode("utf-8")
+    content = gh.get_repo(repo).get_contents(path, ref)
+    if isinstance(content, list):
+        raise Exception(f"multiple files found for {repo}/{path}/{ref}")
+    return content.decoded_content.decode("utf-8")
 
 
 def lookup_graphql_query_results(query: str, **kwargs: dict[str, Any]) -> list[Any]:

reconcile/utils/smtp_client.py

@@ -70,7 +70,7 @@ class SmtpClient:
             self.send_mail([name], subject, body)
 
     @retry()
-    def send_mail(self, names: str, subject: str, body: str) -> None:
+    def send_mail(self, names: Iterable[str], subject: str, body: str) -> None:
         msg = MIMEMultipart()
         from_name = str(Header("App SRE team automation", "utf-8"))
         msg["From"] = formataddr((from_name, self.user))