fix: Adjust the code to be PEP compliant (#43)

Author: ZPascal

grafana_api/alerting_provisioning.py

@@ -80,7 +80,7 @@ def add_alert_rule(self, alert_rule: AlertRule, disable_provenance: bool = False
             api_call: dict = Api(self.grafana_api_model).call_the_api(
                 f"{APIEndpoints.ALERTING_PROVISIONING.value}/alert-rules",
                 RequestsMethods.POST,
-                json.dumps(self.__create_alert_rule_dictionary(alert_rule)),
+                json.dumps(self._create_alert_rule_dictionary(alert_rule)),
                 response_status_code=True,
                 disable_provenance_header=disable_provenance,
             )
@@ -116,7 +116,7 @@ def update_alert_rule(
             api_call: dict = Api(self.grafana_api_model).call_the_api(
                 f"{APIEndpoints.ALERTING_PROVISIONING.value}/alert-rules/{uid}",
                 RequestsMethods.PUT,
-                json.dumps(self.__create_alert_rule_dictionary(alert_rule)),
+                json.dumps(self._create_alert_rule_dictionary(alert_rule)),
                 response_status_code=True,
                 disable_provenance_header=disable_provenance,
             )
@@ -390,7 +390,7 @@ def add_notification_policies(self, route: Route, disable_provenance: bool = Fal
             api_call: dict = Api(self.grafana_api_model).call_the_api(
                 f"{APIEndpoints.ALERTING_PROVISIONING.value}/policies",
                 RequestsMethods.PUT,
-                json.dumps(self.__create_alert_route_dictionary(route)),
+                json.dumps(self._create_alert_route_dictionary(route)),
                 response_status_code=True,
                 disable_provenance_header=disable_provenance,
             )
@@ -473,7 +473,7 @@ def add_mute_timing(
             api_call: dict = Api(self.grafana_api_model).call_the_api(
                 f"{APIEndpoints.ALERTING_PROVISIONING.value}/mute-timings",
                 RequestsMethods.POST,
-                json.dumps(self.__create_mute_timing_dictionary(mute_time_interval)),
+                json.dumps(self._create_mute_timing_dictionary(mute_time_interval)),
                 response_status_code=True,
                 disable_provenance_header=disable_provenance,
             )
@@ -512,7 +512,7 @@ def update_mute_timing(
             api_call: dict = Api(self.grafana_api_model).call_the_api(
                 f"{APIEndpoints.ALERTING_PROVISIONING.value}/mute-timings/{name}",
                 RequestsMethods.PUT,
-                json.dumps(self.__create_mute_timing_dictionary(mute_time_interval)),
+                json.dumps(self._create_mute_timing_dictionary(mute_time_interval)),
                 response_status_code=True,
                 disable_provenance_header=disable_provenance,
             )
@@ -671,7 +671,7 @@ def delete_message_template(self, name: str):
             logging.error("There is no name defined.")
             raise ValueError
 
-    def __create_mute_timing_dictionary(
+    def _create_mute_timing_dictionary(
         self, mute_time_interval: MuteTimeInterval
     ) -> dict:
         """The method includes a functionality to create the mute timing dictionary
@@ -686,13 +686,13 @@ def __create_mute_timing_dictionary(
         return dict(
             {
                 "name": mute_time_interval.name,
-                "time_intervals": self.__create_mute_timing_interval_list(
+                "time_intervals": self._create_mute_timing_interval_list(
                     mute_time_interval.time_intervals
                 ),
             }
         )
 
-    def __create_mute_timing_interval_list(
+    def _create_mute_timing_interval_list(
         self, time_intervals: List[TimeInterval]
     ) -> (list, None):
         """The method includes a functionality to create the mute timing interval list
@@ -712,7 +712,7 @@ def __create_mute_timing_interval_list(
                     {
                         "days_of_month": time_interval.days_of_month,
                         "months": time_interval.months,
-                        "times": self.__create_time_range_list(time_interval.times),
+                        "times": self._create_time_range_list(time_interval.times),
                         "weekdays": time_interval.weekdays,
                         "years": time_interval.years,
                     }
@@ -723,7 +723,7 @@ def __create_mute_timing_interval_list(
             return time_intervals
 
     @staticmethod
-    def __create_time_range_list(timing: List[TimeRange]) -> (list, None):
+    def _create_time_range_list(timing: List[TimeRange]) -> (list, None):
         """The method includes a functionality to create the time range list
 
         Args:
@@ -745,7 +745,7 @@ def __create_time_range_list(timing: List[TimeRange]) -> (list, None):
         else:
             return timing
 
-    def __create_alert_route_dictionary(self, route: Route) -> dict:
+    def _create_alert_route_dictionary(self, route: Route) -> dict:
         """The method includes a functionality to create the alert route dictionary
 
         Args:
@@ -761,18 +761,18 @@ def __create_alert_route_dictionary(self, route: Route) -> dict:
                 "group_by": route.group_by_str,
                 "mute_time_intervals": route.mute_time_intervals,
                 "receiver": route.receiver,
-                "routes": self.__create_alert_routes_list(route.routes),
+                "routes": self._create_alert_routes_list(route.routes),
                 "group_interval": route.group_interval,
                 "group_wait": route.group_wait,
-                "object_matchers": self.__create_object_matcher_list(
+                "object_matchers": self._create_object_matcher_list(
                     route.object_matchers
                 ),
                 "provenance": route.provenance,
                 "repeat_interval": route.repeat_interval,
             }
         )
 
-    def __create_alert_routes_list(self, routes: List[Route]) -> (list, None):
+    def _create_alert_routes_list(self, routes: List[Route]) -> (list, None):
         """The method includes a functionality to create the alert route list
 
         Args:
@@ -786,14 +786,14 @@ def __create_alert_routes_list(self, routes: List[Route]) -> (list, None):
 
         if routes is not None and isinstance(routes, list):
             for route in routes:
-                routes_list.append(self.__create_alert_route_dictionary(route))
+                routes_list.append(self._create_alert_route_dictionary(route))
 
             return routes_list
         else:
             return routes
 
     @staticmethod
-    def __create_object_matcher_list(matchers: List[Matcher]) -> (list, None):
+    def _create_object_matcher_list(matchers: List[Matcher]) -> (list, None):
         """The method includes a functionality to create the object matcher list
 
         Args:
@@ -821,7 +821,7 @@ def __create_object_matcher_list(matchers: List[Matcher]) -> (list, None):
         else:
             return matchers
 
-    def __create_alert_rule_dictionary(self, alert_rule: AlertRule) -> dict:
+    def _create_alert_rule_dictionary(self, alert_rule: AlertRule) -> dict:
         """The method includes a functionality to create the alert rule dictionary
 
         Args:
@@ -835,7 +835,7 @@ def __create_alert_rule_dictionary(self, alert_rule: AlertRule) -> dict:
             {
                 "annotations": alert_rule.annotations,
                 "condition": alert_rule.condition,
-                "data": self.__create_alert_rule_query_list(alert_rule.data),
+                "data": self._create_alert_rule_query_list(alert_rule.data),
                 "execErrState": alert_rule.exec_err_state,
                 "folderUID": alert_rule.folder_uid,
                 "id": alert_rule.id,
@@ -851,7 +851,7 @@ def __create_alert_rule_dictionary(self, alert_rule: AlertRule) -> dict:
             }
         )
 
-    def __create_alert_rule_query_list(self, alert_queries: List[AlertQuery]) -> list:
+    def _create_alert_rule_query_list(self, alert_queries: List[AlertQuery]) -> list:
         """The method includes a functionality to create the alert rule query list
 
         Args:
@@ -867,7 +867,7 @@ def __create_alert_rule_query_list(self, alert_queries: List[AlertQuery]) -> lis
             alert_query_dict: dict = dict(
                 {
                     "datasourceUID": alert_query.datasource_uid,
-                    "model": self.__create_alert_rule_query_model_dictionary(
+                    "model": self._create_alert_rule_query_model_dictionary(
                         alert_query.model
                     ),
                     "queryType": alert_query.query_type,
@@ -883,7 +883,7 @@ def __create_alert_rule_query_list(self, alert_queries: List[AlertQuery]) -> lis
 
         return alert_rule_queries_list
 
-    def __create_alert_rule_query_model_dictionary(
+    def _create_alert_rule_query_model_dictionary(
         self, alert_query_model: AlertRuleQueryModel
     ) -> dict:
         """The method includes a functionality to create the alert rule query model dictionary
@@ -897,7 +897,7 @@ def __create_alert_rule_query_model_dictionary(
 
         return dict(
             {
-                "conditions": self.__create_alert_rule_query_model_condition_list(
+                "conditions": self._create_alert_rule_query_model_condition_list(
                     alert_query_model.conditions
                 ),
                 "datasource": alert_query_model.datasource,
@@ -911,7 +911,7 @@ def __create_alert_rule_query_model_dictionary(
         )
 
     @staticmethod
-    def __create_alert_rule_query_model_condition_list(
+    def _create_alert_rule_query_model_condition_list(
         alert_rule_query_model_conditions: List[AlertRuleQueryModelCondition],
     ) -> list:
         """The method includes a functionality to create the alert rule query model condition list

tests/integrationtest/test_team.py

@@ -64,14 +64,14 @@ def test_get_team_members(self):
         self.assertEqual(1, len(self.team.get_team_members(4)))
 
     def test_d_add_team_member(self):
-        team_id: int = self.__team_creation_util()
+        team_id: int = self._team_creation_util()
 
         self.assertEqual(1, len(self.team.get_team_members(team_id)))
 
         self.team.delete_team_by_id(team_id)
 
     def test_e_delete_team_member(self):
-        team_id: int = self.__team_creation_util()
+        team_id: int = self._team_creation_util()
 
         self.team.delete_team_member(team_id, 8)
 
@@ -94,7 +94,7 @@ def test_update_team_preferences(self):
 
         self.assertEqual("utc", self.team.get_team_preferences(4).get("timezone"))
 
-    def __team_creation_util(self) -> int:
+    def _team_creation_util(self) -> int:
         self.test_a_add_team()
         team_id: int = self.team.search_team(query="Test1").get("teams")[0].get("id")
 

tests/unittests/test_alerting_provisioning.py

@@ -20,7 +20,7 @@
 
 class AlertingProvisioningTestCase(TestCase):
     def setUp(self):
-        self.alert_rule: AlertRule = self.__create_alert_rule_mock()
+        self.alert_rule: AlertRule = self._create_alert_rule_mock()
         self.embedded_contact_point: EmbeddedContactPoint = EmbeddedContactPoint(
             "test", "test", {"test": "test"}
         )
@@ -701,18 +701,18 @@ def test_delete_message_template_not_possible(self, call_the_api_mock):
         with self.assertRaises(Exception):
             alerting_provisioning.delete_message_template("test")
 
-    def test__create_time_range_list(self):
+    def test_create_time_range_list(self):
         model: APIModel = APIModel(host=MagicMock(), token=MagicMock())
         alerting_provisioning: AlertingProvisioning = AlertingProvisioning(
             grafana_api_model=model
         )
         self.assertEqual(
             None,
-            alerting_provisioning._AlertingProvisioning__create_time_range_list(None),
+            alerting_provisioning._create_time_range_list(None),
         )
 
     @staticmethod
-    def __create_alert_rule_mock() -> AlertRule:
+    def _create_alert_rule_mock() -> AlertRule:
         alert_rule_query_model_condition: AlertRuleQueryModelCondition = (
             AlertRuleQueryModelCondition(
                 ["test"], "test", "test", ["test"], ["test"], "test", "test"