fixed review errors

Author: srbhaakamai

linode_api4/groups/monitor.py

@@ -155,39 +155,27 @@ def alert_definitions(
         service_type: Optional[str] = None,
     ) -> Union[PaginatedList, AlertDefinition]:
         """
-        Retrieve one or more alert definitions.
+        Retrieve alert definitions.
 
-        If both `service_type` and `alert_id` are provided, a single
-        :class:`AlertDefinition` instance is returned. If only `service_type` is
-        provided (or neither), a paginated list of :class:`AlertDefinition`
-        objects is returned.
-
-        Examples:
-            alert_definitions = client.monitor.get_alert_definitions()
-            alert_definition = client.load(AlertDefinition, alert_id,"dbaas")
-            alert_definitions_for_service = client.monitor.get_alert_definitions(service_type="dbaas")
+        Returns a paginated collection of :class:`AlertDefinition` objects. If you
+        need to obtain a single :class:`AlertDefinition`, use :meth:`LinodeClient.load`
+        and supply the `service_type` as the parent identifier, for example:
 
+            alerts = client.monitor.alert_definitions()
+            alerts_by_service = client.monitor.alert_definitions(service_type="dbaas")
         .. note:: This endpoint is in beta and requires using the v4beta base URL.
 
         API Documentation:
-            https://techdocs.akamai.com/linode-api/reference/get-alert-definition
             https://techdocs.akamai.com/linode-api/reference/get-alert-definitions
             https://techdocs.akamai.com/linode-api/reference/get-alert-definitions-for-service-type
 
-        :param service_type: If provided, limits the query to alert definitions for
-                             the given service type (e.g. ``"dbaas"``).
+        :param service_type: Optional service type to scope the query (e.g. ``"dbaas"``).
         :type service_type: Optional[str]
-        :param alert_id: If provided, the ID of the alert definition to fetch. When
-                         specifying an ``alert_id``, ``service_type`` must also be
-                         provided.
-        :type alert_id: Optional[int]
         :param filters: Optional filtering expressions to apply to the returned
                         collection. See :doc:`Filtering Collections</linode_api4/objects/filtering>`.
 
-        :returns: A single :class:`AlertDefinition` when ``alert_id`` is used, or
-                  a :class:`PaginatedList` of :class:`AlertDefinition` objects
-                  otherwise.
-        :rtype: Union[AlertDefinition, PaginatedList[AlertDefinition]]
+        :returns: A paginated list of :class:`AlertDefinition` objects.
+        :rtype: PaginatedList[AlertDefinition]
         """
 
         endpoint = "/monitor/alert-definitions"
@@ -291,75 +279,4 @@ def create_alert_definition(
                 json=result,
             )
 
-        return AlertDefinition(self.client, result["id"],service_type, result)
-
-    def update_alert_definition(
-        self,
-        service_type: str,
-        alert_id: int,
-        label: Optional[str] = None,
-        severity: Optional[str] = None,
-        description: Optional[str] = None,
-        rule_criteria: Optional[dict] = None,
-        trigger_conditions: Optional[dict] = None,
-        entity_ids: Optional[list[str]] = None,
-        channel_ids: Optional[list[int]] = None,
-    ) -> AlertDefinition:
-        """
-        Update an existing alert definition.
-
-        Only the parameters provided will be updated; omitted parameters are left
-        unchanged.
-
-        .. note:: This endpoint is in beta and requires using the v4beta base URL.
-
-        API Documentation: https://techdocs.akamai.com/linode-api/reference/put-alert-definition
-
-        :param service_type: Service type of the alert definition to update
-                             (e.g. ``"dbaas"``).
-        :type service_type: str
-        :param alert_id: ID of the alert definition to update.
-        :type alert_id: int
-        :param label: (Optional) New label for the alert definition.
-        :type label: Optional[str]
-        :param severity: (Optional) New severity for the alert. The SDK accepts
-                         this value as provided to the API (commonly an integer).
-        :type severity: Optional[str]
-        :param description: (Optional) New description for the alert definition.
-        :type description: Optional[str]
-        :param rule_criteria: (Optional) New rule criteria to replace the current
-                              definition.
-        :type rule_criteria: Optional[RuleCriteria]
-        :param trigger_conditions: (Optional) New trigger conditions.
-        :type trigger_conditions: Optional[TriggerConditions]
-        :param entity_ids: (Optional) New list of entity IDs to scope the alert.
-        :type entity_ids: Optional[list[str]]
-        :param channel_ids: (Optional) New list of channel IDs to notify.
-        :type channel_ids: Optional[list[int]]
-
-        :returns: The updated :class:`AlertDefinition` as returned by the API.
-        :rtype: AlertDefinition
-        """
-        params = {}
-        if label is not None:
-            params["label"] = label
-        if severity is not None:
-            params["severity"] = severity
-        if description is not None:
-            params["description"] = description
-        if rule_criteria is not None:
-            params["rule_criteria"] = rule_criteria
-        if trigger_conditions is not None:
-            params["trigger_conditions"] = trigger_conditions
-        if entity_ids is not None:
-            params["entity_ids"] = entity_ids
-        if channel_ids is not None:
-            params["channel_ids"] = channel_ids
-        
-        #API will handle check for service_type and alert_id and return correct error if missing
-        result = self.client.put(
-            f"/monitor/services/{service_type}/alert-definitions/{alert_id}",
-            data=params,
-        )
-
-        return AlertDefinition(self.client, result["id"], service_type, result)
+        return AlertDefinition(self.client, result["id"],service_type, result)

linode_api4/objects/monitor.py

@@ -318,19 +318,19 @@ class AlertDefinition(DerivedBase):
     API Documentation: https://techdocs.akamai.com/linode-api/reference/get-alert-definition
     """
 
-    api_endpoint = "/monitor/services/{service}/alert-definitions/{id}"
+    api_endpoint = "/monitor/services/{service_type}/alert-definitions/{id}"
     derived_url_path = "alert-definitions"
-    parent_id_name =  "service"
+    parent_id_name = "service_type"
     id_attribute = "id"
 
     properties = {
         "id": Property(identifier=True),
-        "label": Property(),
-        "severity": Property(),
+        "label": Property(mutable=True),
+        "severity": Property(mutable=True),
         "type": Property(AlertType),
-        "service_type": Property(mutable=True),
-        "status": Property(mutable=True),
-        "has_more_resources": Property(mutable=True),
+        "service_type": Property(),
+        "status": Property(),
+        "has_more_resources": Property(),
         "rule_criteria": Property(RuleCriteria),
         "trigger_conditions": Property(TriggerConditions),
         "alert_channels": Property(List[AlertChannelEnvelope]),
@@ -339,7 +339,7 @@ class AlertDefinition(DerivedBase):
         "updated_by": Property(),
         "created_by": Property(),
         "entity_ids": Property(List[str]),
-        "description": Property(),
+        "description": Property(mutable=True),
         "_class": Property("class"),
     }
 
@@ -366,6 +366,8 @@ class AlertChannel(Base):
     fire. Alert channels define a destination and configuration for
     notifications (for example: email lists, webhooks, PagerDuty, Slack, etc.).
 
+    API Documentation: https://techdocs.akamai.com/linode-api/reference/get-alert-channels
+
     This class maps to the Monitor API's `/monitor/alert-channels` resource
     and is used by the SDK to list, load, and inspect channels.
     """

test/integration/models/monitor/test_monitor.py

@@ -1,4 +1,4 @@
-from time import time
+import time
 
 import pytest
 
@@ -155,7 +155,7 @@ def test_integration_create_get_update_delete_alert_definition(
     description = "E2E alert created by SDK integration test"
 
     # Pick an existing alert channel to attach to the definition; skip if none
-    channels = list(client.monitor.get_alert_channels())
+    channels = list(client.monitor.alert_channels())
     if not channels:
         pytest.skip("No alert channels available on account for creating alert definitions")
 
@@ -187,17 +187,6 @@ def test_integration_create_get_update_delete_alert_definition(
                 # transient errors while polling; continue until timeout
                 pass
 
-        # Update (may fail with 403 if token lacks permissions)
-        new_label = f"{label}-updated"
-        try:
-            updated = client.monitor.update_alert_definition(service_type, created.id, label=new_label)
-            assert getattr(updated, "label", None) == new_label
-        except ApiError as e:
-            if "403" in str(e) or "Access Denied" in str(e):
-                pytest.skip("Token lacks monitor:write permission; skipping update assertion")
-            else:
-                raise
-
     finally:
         if created:
             # Best-effort cleanup; allow transient errors.