clear-skies-aws 1.10.2__py3-none-any.whl → 2.0.2__py3-none-any.whl

clearskies_aws/actions/assume_role.py

@@ -1,6 +1,8 @@
 from __future__ import annotations
+
 from types import ModuleType
-from typing import Optional
+
+
 class AssumeRole:
     """
     Used by the various actions if you need to assume a role before making an AWS call.
@@ -16,54 +18,65 @@ class AssumeRole:
             class User(clearskies.Model):
                 def __init__(self, memory_backend, columns):
                     super().__init__(memory_backend, columns)
+
                 def columns_configuration(self):
-                    return OrderedDict([
-                        clearskies.column_types.string(
-                            'name',
-                            on_change=[
-                                clearskies_aws.actions.sqs(
-                                    queue_url='https://queue.url.example.aws.com',
-                                    assume_role=clearskies_aws.actions.assume_role(
-                                        role_arn='arn:aws:iam:role/name',
-                                        external_id='12345',
+                    return OrderedDict(
+                        [
+                            clearskies.column_types.string(
+                                "name",
+                                on_change=[
+                                    clearskies_aws.actions.sqs(
+                                        queue_url="https://queue.url.example.aws.com",
+                                        assume_role=clearskies_aws.actions.assume_role(
+                                            role_arn="arn:aws:iam:role/name",
+                                            external_id="12345",
+                                        ),
                                     )
-                                )
-                            ],
-                        ),
-                    ])
+                                ],
+                            ),
+                        ]
+                    )
 
     Example:
         Here's a more complicated example with a double-assumme-role to show how to combine them::
 
             first_assume_role = clearskies_aws.actions.assume_role(
-                role_arn='arn:aws:123456789012:iam:role/name',
-                external_id='12345',
+                role_arn="arn:aws:123456789012:iam:role/name",
+                external_id="12345",
             )
             final_assume_role = clearskies_aws.actions.assume_role(
-                role_arn='arn:aws:210987654321:iam:role/name-2',
-                external_id='54321',
+                role_arn="arn:aws:210987654321:iam:role/name-2",
+                external_id="54321",
                 source=first_assume_role,
             )
+
+
             class User(clearskies.Model):
                 def __init__(self, memory_backend, columns):
                     super().__init__(memory_backend, columns)
+
                 def columns_configuration(self):
-                    return OrderedDict([
-                        clearskies.column_types.string(
-                            'name',
-                            on_change=[clearskies_aws.actions.sqs(
-                                queue_url='https://queue.url.example.aws.com',
-                                assume_role=final_assume_role,
-                            )],
-                        ),
-                    ])
+                    return OrderedDict(
+                        [
+                            clearskies.column_types.string(
+                                "name",
+                                on_change=[
+                                    clearskies_aws.actions.sqs(
+                                        queue_url="https://queue.url.example.aws.com",
+                                        assume_role=final_assume_role,
+                                    )
+                                ],
+                            ),
+                        ]
+                    )
 
     """
+
     role_arn = ""
     external_id = ""
     role_session_name = ""
     duration = 3600
-    source: Optional[AssumeRole] = None
+    source: AssumeRole | None = None
 
     def __init__(
         self,
@@ -71,7 +84,7 @@ class AssumeRole:
         external_id: str = "",
         role_session_name: str = "",
         duration: int = 3600,
-        source: Optional[AssumeRole] = None
+        source: AssumeRole | None = None,
     ):
         """Assume a role."""
         self.role_arn = role_arn
@@ -91,7 +104,7 @@ class AssumeRole:
             "DurationSeconds": self.duration,
         }
         if self.external_id:
-            calling_params['ExternalId'] = self.external_id
+            calling_params["ExternalId"] = self.external_id
         credentials = boto3.client("sts").assume_role(**calling_params)["Credentials"]
 
         # now let's make a new session using those

clearskies_aws/actions/ses.py

@@ -1,72 +1,84 @@
-import boto3
-import clearskies
-import datetime
-
-from botocore.exceptions import ClientError
-from clearskies.environment import Environment
-from clearskies.models import Models
-from collections.abc import Sequence
-from typing import Any, Callable, List, Optional, Union
-from types import ModuleType
+from __future__ import annotations
 
-from ..di import StandardDependencies
-from .assume_role import AssumeRole
-from .action_aws import ActionAws
-class SES(ActionAws):
-    _name = "ses"
-
-    def __init__(self, environment: Environment, boto3: boto3, di: StandardDependencies) -> None:
-        """Setup action."""
-        super().__init__(environment, boto3, di)
+import datetime
+from typing import TYPE_CHECKING, Any, Callable
 
-    def configure(
+import clearskies
+import jinja2
+from clearskies import Model
+from clearskies.configs import Any as AnyConfig
+from clearskies.configs import Email, EmailOrEmailListOrCallable, String
+from clearskies.decorators import parameters_to_properties
+from types_boto3_ses import SESClient
+
+from clearskies_aws.actions import action_aws
+
+if TYPE_CHECKING:
+    from clearskies_aws.actions import AssumeRole
+
+
+class SES(action_aws.ActionAws[SESClient]):
+    sender = Email(required=True)
+    to = EmailOrEmailListOrCallable(required=False)
+    cc = EmailOrEmailListOrCallable(required=False)
+    bcc = EmailOrEmailListOrCallable(required=False)
+    subject = String(required=False)
+    message = String(required=False)
+    subject_template = AnyConfig(required=False)
+    message_template = AnyConfig(required=False)
+    subject_template_file = String(required=False)
+    message_template_file = String(required=False)
+    dependencies_for_template: list[Any] = []
+
+    destinations: dict[str, list[str | Callable]] = {
+        "to": [],
+        "cc": [],
+        "bcc": [],
+    }
+
+    @parameters_to_properties
+    def __init__(
         self,
-        sender,
-        to: Optional[Union[list, str,  Callable]] = None,
-        cc: Optional[Union[list, str,  Callable]] = None,
-        bcc: Optional[Union[list, str,  Callable]] = None,
-        subject: Optional[str] = None,
-        message: Optional[str] = None,
-        subject_template: Optional[str] = None,
-        message_template: Optional[str] = None,
-        subject_template_file: Optional[str] = None,
-        message_template_file: Optional[str] = None,
-        assume_role: Optional[AssumeRole] = None,
-        dependencies_for_template: Optional[list[Any]] = None,
-        when: Optional[Callable] = None,
+        sender: str,
+        to: list | str | Callable | None = None,
+        cc: list | str | Callable | None = None,
+        bcc: list | str | Callable | None = None,
+        subject: str | None = None,
+        message: str | None = None,
+        subject_template: jinja2.Template | None = None,
+        message_template: jinja2.Template | None = None,
+        subject_template_file: str | None = None,
+        message_template_file: str | None = None,
+        assume_role: AssumeRole | None = None,
+        dependencies_for_template: list[Any] = [],
+        when: Callable | None = None,
     ) -> None:
         """Configure the rules for this email notification."""
-        super().configure(message_callable=None, when=when, assume_role=assume_role)
-        self.destinations = {
-            "to": [],
-            "cc": [],
-            "bcc": [],
-        }
+        super().__init__(service_name="ses", assume_role=assume_role, when=when)
+
+    def configure(self):
+        self.finalize_and_validate_configuration()
+        # First finalize and validate configuration to set up defaults
+
         # this just moves the data from the various "to" inputs (to, cc, bcc) into the self.destinations
         # dictionary, after normalizing it so that it is always a list.
+        if not self.to and not self.cc and not self.bcc:
+            raise ValueError("You must configure at least one 'to' address or one 'cc' address or one 'bcc' address")
+
         for key in self.destinations.keys():
-            destination_values = locals()[key]
+            destination_values = getattr(self, key, None)
             if not destination_values:
                 continue
             if type(destination_values) == str or callable(destination_values):
                 self.destinations[key] = [destination_values]
             else:
                 self.destinations[key] = destination_values
-        self.subject = subject
-        self.message = message
-        self.sender = sender
-        self.subject_template = None
-        self.message_template = None
-        self.dependencies_for_template = dependencies_for_template if dependencies_for_template else []
-
-        if not to and not cc:
-            raise ValueError("You must configure at least one 'to' address or one 'cc' address")
         num_subjects = 0
         num_messages = 0
-        for source in [subject, subject_template, subject_template_file]:
+        for source in [self.subject, self.subject_template, self.subject_template_file]:
             if source:
                 num_subjects += 1
-        for source in [message, message_template, message_template_file]:
+        for source in [self.message, self.message_template, self.message_template_file]:
             if source:
                 num_messages += 1
         if num_subjects > 1:
@@ -78,25 +90,21 @@ class SES(ActionAws):
                 "More than one of 'message', 'message_template', or 'message_template_file' was set, but only one of these may be set."
             )
 
-        if subject_template_file:
-            import jinja2
-            with open(subject_template_file, "r", encoding="utf-8") as template:
+        if self.subject_template_file:
+            with open(self.subject_template_file, "r", encoding="utf-8") as template:
                 self.subject_template = jinja2.Template(template.read())
-        elif subject_template:
-            import jinja2
-            self.subject_template = jinja2.Template(subject_template)
+        elif self.subject_template and not isinstance(self.subject_template, jinja2.Template):
+            self.subject_template = jinja2.Template(self.subject_template)
 
-        if message_template_file:
-            import jinja2
-            with open(message_template_file, "r", encoding="utf-8") as template:
+        if self.message_template_file:
+            with open(self.message_template_file, "r", encoding="utf-8") as template:
                 self.message_template = jinja2.Template(template.read())
-        elif message_template:
-            import jinja2
-            self.message_template = jinja2.Template(message_template)
+        elif self.message_template and not isinstance(self.message_template, jinja2.Template):
+            self.message_template = jinja2.Template(self.message_template)
 
-    def _execute_action(self, client: ModuleType, model: Models) -> None:
+    def _execute_action(self, client: SESClient, model: Model) -> None:
         """Send a notification as configured."""
-        utcnow = self.di.build('utcnow')
+        utcnow = self.di.build("utcnow")
 
         tos = self._resolve_destination("to", model)
         if not tos:
@@ -118,15 +126,12 @@ class SES(ActionAws):
                         "Data": self._resolve_message_as_text(model, utcnow),
                     },
                 },
-                "Subject": {
-                    "Charset": "utf-8",
-                    "Data": self._resolve_subject(model, utcnow)
-                },
+                "Subject": {"Charset": "utf-8", "Data": self._resolve_subject(model, utcnow)},
             },
             Source=self.sender,
         )
 
-    def _resolve_destination(self, name: str, model: clearskies.Model) -> List[str]:
+    def _resolve_destination(self, name: str, model: clearskies.Model) -> list[str]:
         """
         Return a list of to/cc/bcc addresses.
 
@@ -144,15 +149,19 @@ class SES(ActionAws):
                     more = [more]
                 for entry in more:
                     if not isinstance(entry, str):
-                        raise ValueError(f"I invoked a callable to fetch the '{name}' addresses for model '{model.__class__.__name__}' but it returned something other than a string.  Callables must return a valid email address or a list of email addresses.")
+                        raise ValueError(
+                            f"I invoked a callable to fetch the '{name}' addresses for model '{model.__class__.__name__}' but it returned something other than a string.  Callables must return a valid email address or a list of email addresses."
+                        )
                     if "@" not in entry:
-                        raise ValueError(f"I invoked a callable to fetch the '{name}' addresses for model '{model.__class__.__name__}' but it returned a non-email address.  Callables must return a valid email address or a list of email addresses.")
+                        raise ValueError(
+                            f"I invoked a callable to fetch the '{name}' addresses for model '{model.__class__.__name__}' but it returned a non-email address.  Callables must return a valid email address or a list of email addresses."
+                        )
                 resolved.extend(more)
                 continue
             if "@" in destination:
                 resolved.append(destination)
                 continue
-            resolved.append(model.get(destination))
+            resolved.append(getattr(model, destination))
         return resolved
 
     def _resolve_message_as_html(self, model: clearskies.Model, now: datetime.datetime) -> str:

clearskies_aws/actions/sns.py

@@ -1,42 +1,39 @@
-import boto3
-import clearskies
-import datetime
-import json
+from __future__ import annotations
 
-from botocore.exceptions import ClientError
-from collections.abc import Sequence
-from clearskies.environment import Environment
-from clearskies.models import Models
-from types import ModuleType
-from typing import List, Optional, Callable, cast
+from typing import Callable
+
+from clearskies import Model
+from clearskies.configs import Callable as CallableConfig
+from clearskies.configs import String
+from clearskies.decorators import parameters_to_properties
+from types_boto3_sns import SNSClient
 
-from ..di import StandardDependencies
-from .assume_role import AssumeRole
 from .action_aws import ActionAws
-class SNS(ActionAws):
-    _name = "sns"
+from .assume_role import AssumeRole
 
-    def __init__(self, environment: Environment, boto3: boto3, di: StandardDependencies) -> None:
-        super().__init__(environment, boto3, di)
 
-    def configure(
+class SNS(ActionAws[SNSClient]):
+    topic = String(required=False)
+    topic_environment_key = String(required=False)
+    topic_callable = CallableConfig(required=False)
+
+    @parameters_to_properties
+    def __init__(
         self,
         topic=None,
         topic_environment_key=None,
-        topic_callable: Optional[Callable] = None,
-        message_callable: Optional[Callable] = None,
-        when: Optional[Callable] = None,
-        assume_role: Optional[AssumeRole] = None,
+        topic_callable: Callable | None = None,
+        message_callable: Callable | None = None,
+        when: Callable | None = None,
+        assume_role: AssumeRole | None = None,
     ) -> None:
-        """Configures the action for SNS."""
-        super().configure(message_callable=message_callable, when=when, assume_role=assume_role)
-
-        self.topic = topic
-        self.topic_environment_key = topic_environment_key
-        self.topic_callable = topic_callable
+        """Configure the SNS action."""
+        super().__init__(service_name="sns", message_callable=message_callable, when=when, assume_role=assume_role)
 
+    def configure(self):
+        self.finalize_and_validate_configuration()
         topics = 0
-        for value in [topic, topic_environment_key, topic_callable]:
+        for value in [self.topic, self.topic_environment_key, self.topic_callable]:
             if value:
                 topics += 1
         if topics > 1:
@@ -46,7 +43,7 @@ class SNS(ActionAws):
         if not topics:
             raise ValueError("You must provide at least one of 'topic', 'topic_environment_key', or 'topic_callable'.")
 
-    def _execute_action(self, client: ModuleType, model: Models) -> None:
+    def _execute_action(self, client: SNSClient, model: Model) -> None:
         """Send a notification as configured."""
         topic_arn = self.get_topic_arn(model)
         if not topic_arn:
@@ -56,7 +53,7 @@ class SNS(ActionAws):
             Message=self.get_message_body(model),
         )
 
-    def get_topic_arn(self, model: Models) -> str:
+    def get_topic_arn(self, model: Model) -> str:
         if self.topic:
             return self.topic
         if self.topic_environment_key:

clearskies_aws/actions/sqs.py

@@ -1,44 +1,41 @@
-import boto3
-import json
-import datetime
+from __future__ import annotations
 
-from botocore.exceptions import ClientError
-from clearskies.environment import Environment
+from typing import Callable
+
+from clearskies.configs import Callable as CallableConfig
+from clearskies.configs import String
+from clearskies.decorators import parameters_to_properties
 from clearskies.model import Model
-from collections.abc import Sequence
-from collections import OrderedDict
-from types import ModuleType
-from typing import List, Optional, Callable, Union
+from types_boto3_sqs import SQSClient
 
-from ..di import StandardDependencies
 from . import assume_role
 from .action_aws import ActionAws
-class SQS(ActionAws):
-    _name = "sqs"
 
-    def __init__(self, environment: Environment, boto3: boto3, di: StandardDependencies) -> None:
-        """Setup action."""
-        super().__init__(environment, boto3, di)
 
-    def configure(
+class SQS(ActionAws[SQSClient]):
+    queue_url = String(required=False)
+    queue_url_environment_key = String(required=False)
+    queue_url_callable = CallableConfig(required=False)
+    message_group_id = CallableConfig(required=False)
+
+    @parameters_to_properties
+    def __init__(
         self,
-        queue_url: str = '',
-        queue_url_environment_key: str = '',
-        queue_url_callable: Optional[Callable] = None,
-        message_callable: Optional[Callable] = None,
-        when: Optional[Callable] = None,
-        assume_role: Optional[assume_role.AssumeRole] = None,
-        message_group_id: Optional[Union[str, Callable]] = None,
+        queue_url: str = "",
+        queue_url_environment_key: str = "",
+        queue_url_callable: Callable | None = None,
+        message_callable: Callable | None = None,
+        when: Callable | None = None,
+        assume_role: assume_role.AssumeRole | None = None,
+        message_group_id: str | Callable | None = None,
     ) -> None:
-        super().configure(message_callable=message_callable, when=when, assume_role=assume_role)
-
-        self.queue_url = queue_url
-        self.queue_url_environment_key = queue_url_environment_key
-        self.queue_url_callable = queue_url_callable
-        self.message_group_id = message_group_id
+        """Set up the SQS action."""
+        super().__init__(service_name="sqs", message_callable=message_callable, when=when, assume_role=assume_role)
 
+    def configure(self):
+        self.finalize_and_validate_configuration()
         queue_urls = 0
-        for value in [queue_url, queue_url_environment_key, queue_url_callable]:
+        for value in [self.queue_url, self.queue_url_environment_key, self.queue_url_callable]:
             if value:
                 queue_urls += 1
         if queue_urls > 1:
@@ -49,12 +46,12 @@ class SQS(ActionAws):
             raise ValueError(
                 "You must provide at least one of 'queue_url', 'queue_url_environment_key', or 'queue_url_callable'."
             )
-        if message_group_id and not callable(message_group_id) and not isinstance(message_group_id, str):
+        if self.message_group_id and not callable(self.message_group_id) and not isinstance(self.message_group_id, str):
             raise ValueError(
                 "If provided, 'message_group_id' must be a string or callable, but the provided value was neither."
             )
 
-    def _execute_action(self, client: ModuleType, model: Model) -> None:
+    def _execute_action(self, client: SQSClient, model: Model) -> None:
         """Send a notification as configured."""
         params = {
             "QueueUrl": self.get_queue_url(model),
@@ -67,7 +64,9 @@ class SQS(ActionAws):
             if callable(self.message_group_id):
                 message_group_id = self.di.call_function(self.message_group_id, model=model)
                 if not isinstance(message_group_id, str):
-                    raise ValueError(f"I called the message_group_id function for SQS for model '{model.__class__.__name__}' but the value it returned was not a string.  The message group id must be a string.")
+                    raise ValueError(
+                        f"I called the message_group_id function for SQS for model '{model.__class__.__name__}' but the value it returned was not a string.  The message group id must be a string."
+                    )
             else:
                 message_group_id = self.message_group_id
             params["MessageGroupId"] = message_group_id

clearskies_aws/actions/step_function.py

@@ -1,39 +1,45 @@
-import boto3
+from __future__ import annotations
 
-from clearskies.environment import Environment
-from clearskies.models import Models
-from types import ModuleType
-from typing import List, Optional, Callable, cast
+from typing import Callable
+
+import boto3
+from clearskies import Model
+from clearskies.configs import Callable as CallableConfig
+from clearskies.configs import String
+from clearskies.decorators import parameters_to_properties
+from types_boto3_stepfunctions import SFNClient
 
-from ..di import StandardDependencies
-from .assume_role import AssumeRole
 from .action_aws import ActionAws
-class StepFunction(ActionAws):
-    _name = "stepfunctions"
+from .assume_role import AssumeRole
+
 
-    def __init__(self, environment: Environment, boto3: boto3, di: StandardDependencies) -> None:
-        super().__init__(environment, boto3, di)
+class StepFunction(ActionAws[SFNClient]):
+    arn = String(required=False)
+    arn_environment_key = String(required=False)
+    arn_callable = CallableConfig(required=False)
+    column_to_store_execution_arn = String(required=False)
 
-    def configure(
+    @parameters_to_properties
+    def __init__(
         self,
-        arn: Optional[str]=None,
-        arn_environment_key: Optional[str] = None,
-        arn_callable: Optional[Callable] = None,
-        column_to_store_execution_arn: Optional[str] = None,
-        message_callable: Optional[Callable] = None,
-        when: Optional[Callable] = None,
-        assume_role: Optional[AssumeRole] = None,
+        arn: str | None = None,
+        arn_environment_key: str | None = None,
+        arn_callable: Callable | None = None,
+        column_to_store_execution_arn: str | None = None,
+        message_callable: Callable | None = None,
+        when: Callable | None = None,
+        assume_role: AssumeRole | None = None,
     ) -> None:
-        """Configures the action for the step function."""
-        super().configure(message_callable=message_callable, when=when, assume_role=assume_role)
+        """Configure the Step Function action."""
+        super().__init__(
+            service_name="stepfunctions", message_callable=message_callable, when=when, assume_role=assume_role
+        )
 
-        self.arn = arn
-        self.arn_environment_key = arn_environment_key
-        self.arn_callable = arn_callable
-        self.column_to_store_execution_arn = column_to_store_execution_arn
+    def configure(self):
+        self.finalize_and_validate_configuration()
 
         arns = 0
-        for value in [arn, arn_environment_key, arn_callable]:
+        for value in [self.arn, self.arn_environment_key, self.arn_callable]:
             if value:
                 arns += 1
         if arns > 1:
@@ -43,22 +49,23 @@ class StepFunction(ActionAws):
         if not arns:
             raise ValueError("You must provide at least one of 'arn', 'arn_environment_key', or 'arn_callable'.")
 
-    def _execute_action(self, client: ModuleType, model: Models) -> None:
+    def _execute_action(self, client: SFNClient, model: Model) -> None:
         """Send a notification as configured."""
         arn = self.get_arn(model)
         default_region = self.default_region()
-        arn_region = arn.split(':')[3]
+        arn_region = arn.split(":")[3]
         if default_region and default_region != arn_region:
-            client = self._getClient(region=arn_region)
+            self.region = arn_region
+            client = self._get_client()
         response = client.start_execution(
             stateMachineArn=self.get_arn(model),
             input=self.get_message_body(model),
         )
 
         if self.column_to_store_execution_arn:
-            model.save({self.column_to_store_execution_arn: response['executionArn']})
+            model.save({self.column_to_store_execution_arn: response["executionArn"]})
 
-    def get_arn(self, model: Models) -> str:
+    def get_arn(self, model: Model) -> str:
         if self.arn:
             return self.arn
         if self.arn_environment_key:

clearskies_aws/backends/__init__.py

@@ -1,9 +1,16 @@
-from .dynamo_db_backend import DynamoDBBackend
-from .dynamo_db_parti_ql_backend import DynamoDBPartiQLBackend, DynamoDBPartiQLCursor
-from .dynamo_db_condition_parser import DynamoDBConditionParser
-from .sqs_backend import SqsBackend
+from __future__ import annotations
+
+from clearskies_aws.backends.backend import Backend
+from clearskies_aws.backends.dynamo_db_backend import DynamoDBBackend
+from clearskies_aws.backends.dynamo_db_condition_parser import DynamoDBConditionParser
+from clearskies_aws.backends.dynamo_db_parti_ql_backend import (
+    DynamoDBPartiQLBackend,
+    DynamoDBPartiQLCursor,
+)
+from clearskies_aws.backends.sqs_backend import SqsBackend
 
 __all__ = [
+    "Backend",
     "DynamoDBBackend",
     "SqsBackend",
     "DynamoDBPartiQLBackend",