chore: split off some general functions to separate file

Author: mxmehl

gh_org_mgr/_gh_org.py

@@ -24,6 +24,12 @@
 from jwt.exceptions import InvalidKeyError
 
 from ._gh_api import get_github_secrets_from_env, run_graphql_query
+from ._helpers import (
+    compare_two_dicts,
+    compare_two_lists,
+    pretty_print_dict,
+    sluggify_teamname,
+)
 from ._stats import OrgChanges
 
 
@@ -64,12 +70,6 @@ class GHorg:  # pylint: disable=too-many-instance-attributes, too-many-lines
     # --------------------------------------------------------------------------
     # Helper functions
     # --------------------------------------------------------------------------
-    def _sluggify_teamname(self, team: str) -> str:
-        """Slugify a GitHub team name"""
-        # TODO: this is very naive, no other special chars are
-        # supported, or multiple spaces etc.
-        return team.replace(" ", "-")
-
     # amazonq-ignore-next-line
     def login(
         self, orgname: str, token: str = "", app_id: str | int = "", app_private_key: str = ""
@@ -120,88 +120,9 @@ def ratelimit(self):
             "Current rate limit: %s/%s (reset: %s)", core.remaining, core.limit, core.reset
         )
 
-    def pretty_print_dict(self, dictionary: dict) -> str:
-        """Convert a dict to a pretty-printed output"""
-
-        # Censor sensible fields
-        def censor_half_string(string: str) -> str:
-            """Censor 50% of a string (rounded up)"""
-            half1 = int(len(string) / 2)
-            half2 = len(string) - half1
-            return string[:half1] + "*" * (half2)
-
-        sensible_keys = ["gh_token", "gh_app_private_key"]
-        for key in sensible_keys:
-            if value := dictionary.get(key, ""):
-                dictionary[key] = censor_half_string(value)
-
-        # Print dict nicely
-        def pretty(d, indent=0):
-            string = ""
-            for key, value in d.items():
-                string += "  " * indent + str(key) + ":\n"
-                if isinstance(value, dict):
-                    string += pretty(value, indent + 1)
-                else:
-                    string += "  " * (indent + 1) + str(value) + "\n"
-
-            return string
-
-        return pretty(dictionary)
-
     def pretty_print_dataclass(self) -> str:
         """Convert this dataclass to a pretty-printed output"""
-        return self.pretty_print_dict(asdict(self))
-
-    def compare_two_lists(self, list1: list[str], list2: list[str]):
-        """
-        Compares two lists of strings and returns a tuple containing elements
-        missing in each list and common elements.
-
-        Args:
-            list1 (list of str): The first list of strings.
-            list2 (list of str): The second list of strings.
-
-        Returns:
-            tuple: A tuple containing three lists:
-                1. The first list contains elements in `list2` that are missing in `list1`.
-                2. The second list contains elements that are present in both `list1` and `list2`.
-                3. The third list contains elements in `list1` that are missing in `list2`.
-
-        Example:
-            >>> list1 = ["apple", "banana", "cherry"]
-            >>> list2 = ["banana", "cherry", "date", "fig"]
-            >>> compare_lists(list1, list2)
-            (['date', 'fig'], ['banana', 'cherry'], ['apple'])
-        """
-        # Convert lists to sets for easier comparison
-        set1, set2 = set(list1), set(list2)
-
-        # Elements in list2 that are missing in list1
-        missing_in_list1 = list(set2 - set1)
-
-        # Elements present in both lists
-        common_elements = list(set1 & set2)
-
-        # Elements in list1 that are missing in list2
-        missing_in_list2 = list(set1 - set2)
-
-        # Return the result as a tuple
-        return (missing_in_list1, common_elements, missing_in_list2)
-
-    def compare_two_dicts(self, dict1: dict, dict2: dict) -> dict[str, dict[str, str | int | None]]:
-        """Compares two dictionaries. Assume that the keys are the same. Output
-        a dict with keys that have differing values"""
-        # Create an empty dictionary to store differences
-        differences = {}
-
-        # Iterate through the keys (assuming both dictionaries have the same keys)
-        for key in dict1:
-            # Compare the values for each key
-            if dict1[key] != dict2[key]:
-                differences[key] = {"dict1": dict1[key], "dict2": dict2[key]}
-
-        return differences
+        return pretty_print_dict(asdict(self), sensible_keys=["gh_token", "gh_app_private_key"])
 
     def _resolve_gh_username(self, username: str, teamname: str) -> NamedUser | None:
         """Turn a username into a proper GitHub user object"""
@@ -296,7 +217,7 @@ def sync_org_owners(self, dry: bool = False, force: bool = False) -> None:
             return
 
         # Get differences between the current and configured owners
-        owners_remove, owners_ok, owners_add = self.compare_two_lists(
+        owners_remove, owners_ok, owners_add = compare_two_lists(
             self.configured_org_owners, [user.login for user in self.current_org_owners]
         )
         # Compare configured (lower-cased) owners with lower-cased list of current owners
@@ -375,7 +296,7 @@ def create_missing_teams(self, dry: bool = False):
         for team, attributes in self.configured_teams.items():
             if team not in existent_team_names:
                 if parent := attributes.get("parent"):  # type: ignore
-                    parent_id = self.org.get_team_by_slug(self._sluggify_teamname(parent)).id
+                    parent_id = self.org.get_team_by_slug(sluggify_teamname(parent)).id
 
                     logging.info("Creating team '%s' with parent ID '%s'", team, parent_id)
                     self.stats.create_team(team)
@@ -417,7 +338,7 @@ def _prepare_team_config_for_sync(
             # team coming from config, and valid string
             elif isinstance(parent, str) and parent:
                 team_config["parent_team_id"] = self.org.get_team_by_slug(
-                    self._sluggify_teamname(parent)
+                    sluggify_teamname(parent)
                 ).id
             # empty from string, so probably default value
             elif isinstance(parent, str) and not parent:
@@ -478,7 +399,7 @@ def sync_current_teams_settings(self, dry: bool = False) -> None:
             )
 
             # Compare settings and update if necessary
-            if differences := self.compare_two_dicts(configured_team_configs, current_team_configs):
+            if differences := compare_two_dicts(configured_team_configs, current_team_configs):
                 # Log differences
                 logging.info(
                     "Team settings for '%s' differ from the configuration. Updating them:",
@@ -497,7 +418,7 @@ def sync_current_teams_settings(self, dry: bool = False) -> None:
                         logging.critical(
                             "Team '%s' settings could not be edited. Error: \n%s",
                             team.name,
-                            self.pretty_print_dict(exc.data),
+                            pretty_print_dict(exc.data),
                         )
                         sys.exit(1)
             else:
@@ -772,7 +693,7 @@ def _create_perms_changelist_for_teams(
 
             # Convert team name to Team object
             try:
-                team = self.org.get_team_by_slug(self._sluggify_teamname(team_name))
+                team = self.org.get_team_by_slug(sluggify_teamname(team_name))
             # Team not found, probably because a new team should be created, but it's a dry-run
             except UnknownObjectException:
                 logging.debug(
@@ -795,7 +716,7 @@ def _create_perms_changelist_for_teams(
                     attributes={
                         "id": 0,
                         "name": team_name,
-                        "slug": self._sluggify_teamname(team_name),
+                        "slug": sluggify_teamname(team_name),
                     },
                     completed=True,  # Mark as fully initialized
                 )

gh_org_mgr/_helpers.py

@@ -0,0 +1,121 @@
+# SPDX-FileCopyrightText: 2025 DB Systel GmbH
+#
+# SPDX-License-Identifier: Apache-2.0
+
+"""Helper functions"""
+
+from dataclasses import asdict
+
+
+def sluggify_teamname(team: str) -> str:
+    """Slugify a GitHub team name"""
+    # TODO: this is very naive, no other special chars are
+    # supported, or multiple spaces etc.
+    return team.replace(" ", "-")
+
+
+def compare_two_lists(list1: list[str], list2: list[str]):
+    """
+    Compares two lists of strings and returns a tuple containing elements
+    missing in each list and common elements.
+
+    Args:
+        list1 (list of str): The first list of strings.
+        list2 (list of str): The second list of strings.
+
+    Returns:
+        tuple: A tuple containing three lists:
+            1. The first list contains elements in `list2` that are missing in `list1`.
+            2. The second list contains elements that are present in both `list1` and `list2`.
+            3. The third list contains elements in `list1` that are missing in `list2`.
+
+    Example:
+        >>> list1 = ["apple", "banana", "cherry"]
+        >>> list2 = ["banana", "cherry", "date", "fig"]
+        >>> compare_lists(list1, list2)
+        (['date', 'fig'], ['banana', 'cherry'], ['apple'])
+    """
+    # Convert lists to sets for easier comparison
+    set1, set2 = set(list1), set(list2)
+
+    # Elements in list2 that are missing in list1
+    missing_in_list1 = list(set2 - set1)
+
+    # Elements present in both lists
+    common_elements = list(set1 & set2)
+
+    # Elements in list1 that are missing in list2
+    missing_in_list2 = list(set1 - set2)
+
+    # Return the result as a tuple
+    return (missing_in_list1, common_elements, missing_in_list2)
+
+
+def compare_two_dicts(dict1: dict, dict2: dict) -> dict[str, dict[str, str | int | None]]:
+    """Compares two dictionaries. Assume that the keys are the same. Output
+    a dict with keys that have differing values"""
+    # Create an empty dictionary to store differences
+    differences = {}
+
+    # Iterate through the keys (assuming both dictionaries have the same keys)
+    for key in dict1:
+        # Compare the values for each key
+        if dict1[key] != dict2[key]:
+            differences[key] = {"dict1": dict1[key], "dict2": dict2[key]}
+
+    return differences
+
+
+def pretty_print_dict(dictionary: dict, sensible_keys: None | list[str] = None) -> str:
+    """Convert a dict to a pretty-printed output"""
+
+    # Censor sensible fields
+    def censor_half_string(string: str) -> str:
+        """Censor 50% of a string (rounded up)"""
+        half1 = int(len(string) / 2)
+        half2 = len(string) - half1
+        return string[:half1] + "*" * (half2)
+
+    if sensible_keys is None:
+        sensible_keys = []
+    for key in sensible_keys:
+        if value := dictionary.get(key, ""):
+            dictionary[key] = censor_half_string(value)
+
+    # Print dict nicely
+    def pretty(d, indent=0):
+        string = ""
+        for key, value in d.items():
+            string += "  " * indent + str(key) + ":\n"
+            if isinstance(value, dict):
+                string += pretty(value, indent + 1)
+            else:
+                string += "  " * (indent + 1) + str(value) + "\n"
+
+        return string
+
+    return pretty(dictionary)
+
+
+def pretty_print_dataclass(dc):
+    """Convert dataclass to a pretty-printed output"""
+    pretty_print_dict(asdict(dc))
+
+
+def implement_changes_into_class(dc_object, **changes: bool | str | list[str]):
+    """Smartly add changes to a (data)class object"""
+    for attribute, value in changes.items():
+        current_value = getattr(dc_object, attribute)
+        # attribute is list
+        if isinstance(current_value, list):
+            # input change is list
+            if isinstance(value, list):
+                current_value.extend(value)
+            # input change is not list
+            else:
+                current_value.append(value)
+        # All other cases, bool
+        else:
+            setattr(dc_object, attribute, value)
+
+    return dc_object