update rules archive/unarchive

Author: alexluck-sift

python/lib/sift_client/_internal/low_level_wrappers/rules.py

@@ -4,23 +4,23 @@
 from typing import TYPE_CHECKING, Any, cast
 
 from sift.rules.v1.rules_pb2 import (
-    BatchDeleteRulesRequest,
+    ArchiveRuleRequest,
+    BatchArchiveRulesRequest,
     BatchGetRulesRequest,
     BatchGetRulesResponse,
-    BatchUndeleteRulesRequest,
+    BatchUnarchiveRulesRequest,
     BatchUpdateRulesRequest,
     BatchUpdateRulesResponse,
     CalculatedChannelConfig,
     ContextualChannels,
     CreateRuleRequest,
     CreateRuleResponse,
-    DeleteRuleRequest,
     GetRuleRequest,
     GetRuleResponse,
     ListRulesRequest,
     RuleAssetConfiguration,
     RuleConditionExpression,
-    UndeleteRuleRequest,
+    UnarchiveRuleRequest,
     UpdateConditionRequest,
     UpdateRuleRequest,
     UpdateRuleResponse,
@@ -328,7 +328,7 @@ async def archive_rule(self, rule_id: str | None = None, client_key: str | None
         if client_key is not None:
             request_kwargs["client_key"] = client_key
 
-        request = DeleteRuleRequest(**request_kwargs)
+        request = ArchiveRuleRequest(**request_kwargs)
         await self._grpc_client.get_stub(RuleServiceStub).ArchiveRule(request)
 
     async def batch_archive_rules(
@@ -338,7 +338,7 @@ async def batch_archive_rules(
 
         Args:
             rule_ids: List of rule IDs to archive.
-            client_keys: List of client keys to delete. If both are provided, rule_ids will be used.
+            client_keys: List of client keys to archive. If both are provided, rule_ids will be used.
 
         Raises:
             ValueError: If neither rule_ids nor client_keys is provided.
@@ -352,59 +352,53 @@ async def batch_archive_rules(
         if client_keys is not None:
             request_kwargs["client_keys"] = client_keys
 
-        request = BatchDeleteRulesRequest(**request_kwargs)
-        await self._grpc_client.get_stub(RuleServiceStub).BatchDeleteRules(request)
+        request = BatchArchiveRulesRequest(**request_kwargs)
+        await self._grpc_client.get_stub(RuleServiceStub).BatchArchiveRules(request)
 
-    async def restore_rule(self, rule_id: str | None = None, client_key: str | None = None) -> Rule:
-        """Restore a rule.
+    async def unarchive_rule(self, rule_id: str | None = None, client_key: str | None = None) -> Rule:
+        """Unarchive a rule.
 
         Args:
-            rule_id: The rule ID to restore.
-            client_key: The client key to restore.
+            rule_id: The rule ID to unarchive.
+            client_key: The client key to unarchive.
 
         Returns:
-            The restored Rule.
+            The unarchived Rule.
 
         Raises:
             ValueError: If neither rule_id nor client_key is provided.
         """
-        if rule_id is None and client_key is None:
-            raise ValueError("Either rule_id or client_key must be provided")
-
         request_kwargs: dict[str, Any] = {}
         if rule_id is not None:
             request_kwargs["rule_id"] = rule_id
         if client_key is not None:
             request_kwargs["client_key"] = client_key
 
-        request = UndeleteRuleRequest(**request_kwargs)
-        await self._grpc_client.get_stub(RuleServiceStub).UndeleteRule(request)
-        # Get the restored rule
+        request = UnarchiveRuleRequest(**request_kwargs)
+        await self._grpc_client.get_stub(RuleServiceStub).UnarchiveRule(request)
+        # Get the unarchived rule
         return await self.get_rule(rule_id=rule_id, client_key=client_key)
 
-    async def batch_restore_rules(
+    async def batch_unarchive_rules(
         self, rule_ids: list[str] | None = None, client_keys: list[str] | None = None
     ) -> None:
-        """Batch restore rules.
+        """Batch unarchive rules.
 
         Args:
-            rule_ids: List of rule IDs to restore.
-            client_keys: List of client keys to restore.
+            rule_ids: List of rule IDs to unarchive.
+            client_keys: List of client keys to unarchive.
 
         Raises:
             ValueError: If neither rule_ids nor client_keys is provided.
         """
-        if rule_ids is None and client_keys is None:
-            raise ValueError("Either rule_ids or client_keys must be provided")
-
         request_kwargs: dict[str, Any] = {}
         if rule_ids is not None:
             request_kwargs["rule_ids"] = rule_ids
         if client_keys is not None:
             request_kwargs["client_keys"] = client_keys
 
-        request = BatchUndeleteRulesRequest(**request_kwargs)
-        await self._grpc_client.get_stub(RuleServiceStub).BatchUndeleteRules(request)
+        request = BatchUnarchiveRulesRequest(**request_kwargs)
+        await self._grpc_client.get_stub(RuleServiceStub).BatchUnarchiveRules(request)
 
     async def list_rules(
         self,

python/lib/sift_client/resources/rules.py

@@ -38,18 +38,28 @@ async def get(
         *,
         rule_id: str | None = None,
         client_key: str | None = None,
-    ) -> Rule:
+        rule_ids: list[str] | None = None,
+        client_keys: list[str] | None = None,
+    ) -> Rule | list[Rule]:
         """Get a Rule.
 
         Args:
             rule_id: The ID of the rule.
             client_key: The client key of the rule.
+            rule_ids: List of rule IDs to get.
+            client_keys: List of client keys to get.
 
         Returns:
-            The Rule.
+            The Rule or Rules.
         """
-        rule = await self._low_level_client.get_rule(rule_id=rule_id, client_key=client_key)
-        return self._apply_client_to_instance(rule)
+        if rule_id or client_key:
+            rule = await self._low_level_client.get_rule(rule_id=rule_id, client_key=client_key)
+            return self._apply_client_to_instance(rule)
+        else:
+            rules = await self._low_level_client.batch_get_rules(
+                rule_ids=rule_ids, client_keys=client_keys
+            )
+            return self._apply_client_to_instances(rules)
 
     async def list_(
         self,
@@ -166,6 +176,7 @@ async def archive(
         self,
         *,
         rule: str | Rule | None = None,
+        client_key: str | None = None,
         rules: list[Rule] | None = None,
         rule_ids: list[str] | None = None,
         client_keys: list[str] | None = None,
@@ -174,89 +185,50 @@ async def archive(
 
         Args:
             rule: The Rule to archive.
+            client_key: The client key or the Rule to archive.
             rules: The Rules to archive.
             rule_ids: The rule IDs to archive.
-            client_keys: The client keys to archive.
-        """
-        if rule:
-            if isinstance(rule, Rule):
-                await self._low_level_client.archive_rule(rule_id=rule.id_)
-            else:
-                await self._low_level_client.archive_rule(rule_id=rule)
-        elif rules:
-            if len(rules) == 1:
-                await self._low_level_client.archive_rule(rule_id=rules[0].id_)
-            else:
-                await self._low_level_client.batch_archive_rules(
-                    rule_ids=[r.id_ for r in rules],  # type: ignore
-                )
-        elif rule_ids:
-            if len(rule_ids) == 1:
-                await self._low_level_client.archive_rule(rule_id=rule_ids[0])
-            else:
-                await self._low_level_client.batch_archive_rules(rule_ids=rule_ids)
-        elif client_keys:
-            await self._low_level_client.batch_archive_rules(client_keys=client_keys)
-        else:
-            raise ValueError("Either rules, rule_ids, or client_keys must be provided")
-
-    async def restore(
-        self,
-        *,
-        rule: str | Rule,
-        rule_id: str | None = None,
-        client_key: str | None = None,
-    ) -> Rule:
-        """Restore a rule.
-
-        Args:
-            rule: The Rule or rule ID to restore.
-            rule_id: The rule ID to restore (alternative to rule parameter).
-            client_key: The client key to restore (alternative to rule parameter).
-
-        Returns:
-            The restored Rule.
+            client_keys: The client keys of the Rules tp archive.
         """
-        if rule_id or client_key:
-            restored_rule = await self._low_level_client.restore_rule(
-                rule_id=rule_id, client_key=client_key
+        if rule or client_key:
+            rule_id = rule._id_or_error if isinstance(rule, Rule) else rule
+            return await self._low_level_client.archive_rule(rule_id=rule_id, client_key=client_key)
+        elif rules or rule_ids or client_keys:
+            rule_ids = rule_ids or [rule._id_or_error for rule in rules]
+            return await self._low_level_client.batch_archive_rules(
+                rule_ids=rule_ids, client_keys=client_keys
             )
         else:
+            raise ValueError("Either rule or rules must be provided")
+
+        async def unarchive(
+                self,
+                *,
+                rule: str | Rule | None = None,
+                client_key: str | None = None,
+                rules: list[Rule] | None = None,
+                rule_ids: list[str] | None = None,
+                client_keys: list[str] | None = None,
+        ) -> None:
+            """Unarchive a Rule or multiple.
+
+            Args:
+            rule: The Rule to restore.
+            client_key: The client key of the Rule to restore.
+            rules: The Rules to restore.
+            rule_ids: The rule IDs to restore.
+            client_keys: The client keys of the Rules to restore.
+            """
+        if rule or client_key:
             rule_id = rule._id_or_error if isinstance(rule, Rule) else rule
-            restored_rule = await self._low_level_client.restore_rule(rule_id=rule_id)
-
-        return self._apply_client_to_instance(restored_rule)
+            return await self._low_level_client.unarchive_rule(rule_id=rule_id, client_key=client_key)
+        elif rules or rule_ids or client_keys:
+            rule_ids = rule_ids or [rule._id_or_error for rule in rules]
+            return await self._low_level_client.batch_unarchive_rules(
+                rule_ids=rule_ids, client_keys=client_keys
+            )
+        else:
+            raise ValueError("Either rule or rules must be provided")
 
-    async def batch_restore(
-        self,
-        *,
-        rule_ids: list[str] | None = None,
-        client_keys: list[str] | None = None,
-    ) -> None:
-        """Batch restore rules.
 
-        Args:
-            rule_ids: List of rule IDs to restore.
-            client_keys: List of client keys to undelete.
-        """
-        await self._low_level_client.batch_restore_rules(rule_ids=rule_ids, client_keys=client_keys)
 
-    async def batch_get(
-        self,
-        *,
-        rule_ids: list[str] | None = None,
-        client_keys: list[str] | None = None,
-    ) -> list[Rule]:
-        """Get multiple rules by rule IDs or client keys.
-
-        Args:
-            rule_ids: List of rule IDs to get.
-            client_keys: List of client keys to get.
-
-        Returns:
-            List of Rules.
-        """
-        rules = await self._low_level_client.batch_get_rules(
-            rule_ids=rule_ids, client_keys=client_keys
-        )
-        return self._apply_client_to_instances(rules)