update rules create pattern

Author: alexluck-sift

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

@@ -7,7 +7,6 @@
     ArchiveRuleRequest,
     BatchArchiveRulesRequest,
     BatchGetRulesRequest,
-    BatchGetRulesResponse,
     BatchUnarchiveRulesRequest,
     BatchUpdateRulesRequest,
     BatchUpdateRulesResponse,
@@ -33,7 +32,7 @@
 from sift_client._internal.low_level_wrappers.base import LowLevelClientBase
 from sift_client.sift_types.rule import (
     Rule,
-    RuleAction,
+    RuleCreate,
     RuleUpdate,
 )
 from sift_client.transport import GrpcClient, WithGrpcClient
@@ -109,66 +108,50 @@ async def batch_get_rules(
 
         request = BatchGetRulesRequest(**request_kwargs)
         response = await self._grpc_client.get_stub(RuleServiceStub).BatchGetRules(request)
-        response = cast("BatchGetRulesResponse", response)
         return [Rule._from_proto(rule) for rule in response.rules]
 
     async def create_rule(
         self,
         *,
-        name: str,
-        description: str,
-        organization_id: str | None = None,
-        client_key: str | None = None,
-        asset_ids: list[str] | None = None,
-        tag_ids: list[str] | None = None,
-        contextual_channels: list[str] | None = None,
-        is_external: bool,
-        expression: str,
-        channel_references: list[ChannelReference],
-        action: RuleAction,
+        create: RuleCreate,
     ) -> Rule:
         """Create a new rule.
 
         Args:
-            name: The name of the rule.
-            description: The description of the rule.
-            organization_id: The organization ID of the rule.
-            client_key: The client key of the rule.
-            asset_ids: The asset IDs of the rule.
-            contextual_channels: Optional contextual channels of the rule.
+            create: The RuleCreate model with the rule configuration.
 
         Returns:
-            The rule ID of the created rule.
+            The created Rule.
         """
         # Convert rule to UpdateRuleRequest
         expression_proto = RuleConditionExpression(
             calculated_channel=CalculatedChannelConfig(
-                expression=expression,
+                expression=create.expression,
                 channel_references={
                     c.channel_reference: ChannelReferenceProto(name=c.channel_identifier)
-                    for c in channel_references
+                    for c in create.channel_references
                 },
             )
         )
         conditions_request = [
             UpdateConditionRequest(
-                expression=expression_proto, actions=[action._to_update_request()]
+                expression=expression_proto, actions=[create.action._to_update_request()]
             )
         ]
         update_request = UpdateRuleRequest(
-            name=name,
-            description=description,
+            name=create.name,
+            description=create.description,
             is_enabled=True,
-            organization_id=organization_id or "",
-            client_key=client_key,
-            is_external=is_external,
+            organization_id=create.organization_id or "",
+            client_key=create.client_key,
+            is_external=create.is_external,
             conditions=conditions_request,
             asset_configuration=RuleAssetConfiguration(
-                asset_ids=asset_ids or [],
-                tag_ids=tag_ids or [],
+                asset_ids=create.asset_ids or [],
+                tag_ids=create.asset_tag_ids or [],
             ),
             contextual_channels=ContextualChannels(
-                channels=[ChannelReferenceProto(name=c) for c in contextual_channels or []]
+                channels=[ChannelReferenceProto(name=c) for c in create.contextual_channels or []]
             ),  # type: ignore
         )
 
@@ -177,7 +160,7 @@ async def create_rule(
             "CreateRuleResponse",
             await self._grpc_client.get_stub(RuleServiceStub).CreateRule(request),
         )
-        return await self.get_rule(rule_id=created_rule.rule_id, client_key=client_key)
+        return await self.get_rule(rule_id=created_rule.rule_id, client_key=create.client_key)
 
     def _update_rule_request_from_update(
         self, rule: Rule, update: RuleUpdate, version_notes: str | None = None

python/lib/sift_client/resources/rules.py

@@ -4,14 +4,13 @@
 
 from sift_client._internal.low_level_wrappers.rules import RulesLowLevelClient
 from sift_client.resources._base import ResourceBase
-from sift_client.sift_types.rule import Rule, RuleAction, RuleUpdate
+from sift_client.sift_types.rule import Rule, RuleCreate, RuleUpdate
 from sift_client.util import cel_utils as cel
 
 if TYPE_CHECKING:
     import re
 
     from sift_client.client import SiftClient
-    from sift_client.sift_types.channel import ChannelReference
 
 
 class RulesAPIAsync(ResourceBase):
@@ -124,34 +123,28 @@ async def find(self, **kwargs) -> Rule | None:
 
     async def create(
         self,
-        name: str,
-        description: str,
-        expression: str,
-        channel_references: list[ChannelReference],
-        action: RuleAction,
-        organization_id: str | None = None,
-        client_key: str | None = None,
-        asset_ids: list[str] | None = None,
-        contextual_channels: list[str] | None = None,
-        is_external: bool = False,
+        create: RuleCreate | dict,
     ) -> Rule:
-        """Create a new rule."""
-        created_rule = await self._low_level_client.create_rule(
-            name=name,
-            description=description,
-            organization_id=organization_id,
-            expression=expression,
-            action=action,
-            channel_references=channel_references,
-            client_key=client_key,
-            asset_ids=asset_ids,
-            contextual_channels=contextual_channels,
-            is_external=is_external,
-        )
+        """Create a new rule.
+
+        Args:
+            create: A RuleCreate object or dictionary with configuration for the new rule.
+
+        Returns:
+            The created Rule.
+        """
+        if isinstance(create, dict):
+            create = RuleCreate.model_validate(create)
+
+        created_rule = await self._low_level_client.create_rule(create=create)
         return self._apply_client_to_instance(created_rule)
 
     async def update(
-        self, rule: str | Rule, update: RuleUpdate | dict, version_notes: str | None = None
+        self,
+        rule: Rule | str,
+        update: RuleUpdate | dict,
+        *,
+        version_notes: str | None = None,
     ) -> Rule:
         """Update a Rule.
 
@@ -172,63 +165,27 @@ async def update(
         updated_rule = await self._low_level_client.update_rule(rule, update, version_notes)
         return self._apply_client_to_instance(updated_rule)
 
-    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,
-    ) -> None:
-        """Archive a rule or multiple.
+    async def archive(self, rule: str | Rule) -> Rule:
+        """Archive a rule.
 
         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 of the Rules tp archive.
+            rule: The id or Rule object of the rule to archive.
+
+        Returns:
+            The archived Rule.
         """
-        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
-            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")
+        return await self.update(rule=rule, update=RuleUpdate(is_archived=True))
+
+    async def unarchive(self, rule: str | Rule) -> Rule:
+        """Unarchive a rule.
+
+        Args:
+            rule: The id or Rule object of the rule to unarchive.
+
+        Returns:
+            The unarchived Rule.
+        """
+        return await self.update(rule=rule, update=RuleUpdate(is_archived=False))
 
 
 

python/lib/sift_client/sift_types/rule.py

@@ -15,6 +15,9 @@
 ChannelReferencesEntry = CalculatedChannelConfig.ChannelReferencesEntry
 del CalculatedChannelConfig
 
+from sift.rules.v1.rules_pb2 import (
+    CreateRuleRequest,
+)
 from sift.rules.v1.rules_pb2 import (
     Rule as RuleProto,
 )
@@ -25,7 +28,7 @@
     RuleVersion as RuleVersionProto,
 )
 
-from sift_client.sift_types._base import BaseType, ModelUpdate
+from sift_client.sift_types._base import BaseType, ModelCreate, ModelUpdate
 from sift_client.sift_types.channel import ChannelReference
 
 if TYPE_CHECKING:
@@ -101,9 +104,11 @@ def update(self, update: RuleUpdate | dict, version_notes: str | None = None) ->
         self._update(updated_rule)
         return self
 
-    def archive(self) -> None:
+    def archive(self) -> Rule:
         """Archive the rule."""
-        self.client.rules.archive(rule=self)
+        updated_rule = self.client.rules.archive(rule=self)
+        self._update(updated_rule)
+        return self
 
     @classmethod
     def _from_proto(cls, proto: RuleProto, sift_client: SiftClient | None = None) -> Rule:
@@ -145,6 +150,30 @@ def _from_proto(cls, proto: RuleProto, sift_client: SiftClient | None = None) ->
         )
 
 
+class RuleCreate(ModelCreate[CreateRuleRequest]):
+    """Model for creating a new Rule.
+
+    Note:
+    - asset_ids applies this rule to those assets.
+    - asset_tag_ids applies this rule to assets with those tags.
+    """
+
+    name: str
+    description: str
+    expression: str
+    channel_references: list[ChannelReference]
+    action: RuleAction
+    organization_id: str | None = None
+    client_key: str | None = None
+    asset_ids: list[str] | None = None
+    asset_tag_ids: list[str] | None = None
+    contextual_channels: list[str] | None = None
+    is_external: bool = False
+
+    def _get_proto_class(self) -> type[CreateRuleRequest]:
+        return CreateRuleRequest
+
+
 class RuleUpdate(ModelUpdate[RuleProto]):
     """Model of the Rule fields that can be updated.