clear-skies-aws 2.0.1__py3-none-any.whl → 2.0.3__py3-none-any.whl

clearskies_aws/actions/sqs.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+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 types_boto3_sqs import SQSClient
+
+from . import assume_role
+from .action_aws import ActionAws
+
+
+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: 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:
+        """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 [self.queue_url, self.queue_url_environment_key, self.queue_url_callable]:
+            if value:
+                queue_urls += 1
+        if queue_urls > 1:
+            raise ValueError(
+                "You can only provide one of 'queue_url', 'queue_url_environment_key', or 'queue_url_callable', but more than one were provided."
+            )
+        if not queue_urls:
+            raise ValueError(
+                "You must provide at least one of 'queue_url', 'queue_url_environment_key', or 'queue_url_callable'."
+            )
+        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: SQSClient, model: Model) -> None:
+        """Send a notification as configured."""
+        params = {
+            "QueueUrl": self.get_queue_url(model),
+            "MessageBody": self.get_message_body(model),
+        }
+        if not params["QueueUrl"]:
+            return
+
+        if self.message_group_id:
+            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."
+                    )
+            else:
+                message_group_id = self.message_group_id
+            params["MessageGroupId"] = message_group_id
+
+        client.send_message(**params)
+
+    def get_queue_url(self, model: Model):
+        if self.queue_url:
+            return self.queue_url
+        if self.queue_url_environment_key:
+            return self.environment.get(self.queue_url_environment_key)
+        return self.di.call_function(self.queue_url_callable, model=model)

clearskies_aws/actions/step_function.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+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 .action_aws import ActionAws
+from .assume_role import AssumeRole
+
+
+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)
+
+    @parameters_to_properties
+    def __init__(
+        self,
+        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:
+        """Configure the Step Function action."""
+        super().__init__(
+            service_name="stepfunctions", message_callable=message_callable, when=when, assume_role=assume_role
+        )
+
+    def configure(self):
+        self.finalize_and_validate_configuration()
+
+        arns = 0
+        for value in [self.arn, self.arn_environment_key, self.arn_callable]:
+            if value:
+                arns += 1
+        if arns > 1:
+            raise ValueError(
+                "You can only provide one of 'arn', 'arn_environment_key', or 'arn_callable', but more than one was provided."
+            )
+        if not arns:
+            raise ValueError("You must provide at least one of 'arn', 'arn_environment_key', or 'arn_callable'.")
+
+    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]
+        if default_region and default_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"]})
+
+    def get_arn(self, model: Model) -> str:
+        if self.arn:
+            return self.arn
+        if self.arn_environment_key:
+            return self.environment.get(self.arn_environment_key)
+        return self.di.call_function(self.arn_callable, model=model)

clearskies_aws/backends/__init__.py

@@ -0,0 +1,19 @@
+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",
+    "DynamoDBPartiQLCursor",
+    "DynamoDBConditionParser",
+]

clearskies_aws/backends/backend.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+from typing import Any, Callable
+
+import clearskies
+import clearskies.model
+import clearskies.query
+from clearskies.autodoc.schema import Schema as AutoDocSchema
+from clearskies.di import inject
+
+from clearskies_aws.di.inject import boto3
+
+
+class Backend(clearskies.Configurable, clearskies.backends.Backend, clearskies.di.InjectableProperties):
+    """
+    Connect models to their data since 2020.
+
+    The backend system acts as a flexible layer between models and their data sources.  By changing the backend attached to a model,
+    you change where the model fetches and saves data.  This might be a database, an in-memory data store, a dynamodb table,
+    an API, and more.  This allows you to interact with a variety of data sources with the models acting as a standardized API.
+    Since endpoints also rely on the models for their functionality, this means that you can easily build API endpoints and
+    more for a variety of data sources with a minimal amount of code.
+
+    Of course, not all data sources support all functionality present in the model.  Therefore, you do still need to have
+    a fair understanding of how your data sources work.
+    """
+
+    supports_n_plus_one = False
+    can_count = True
+
+    boto3 = boto3.Boto3()
+    environment = inject.Environment()
+
+    def update(self, id: int | str, data: dict[str, Any], model: clearskies.model.Model) -> dict[str, Any]:
+        """Update the record with the given id with the information from the data dictionary."""
+        return {}
+
+    def create(self, data: dict[str, Any], model: clearskies.model.Model) -> dict[str, Any]:
+        """Create a record with the information from the data dictionary."""
+        return {}
+
+    def delete(self, id: int | str, model: clearskies.model.Model) -> bool:
+        """Delete the record with the given id."""
+        return True
+
+    def count(self, query: clearskies.query.Query) -> int:
+        """Return the number of records which match the given query configuration."""
+        return 1
+
+    def records(
+        self,
+        query: clearskies.query.Query,
+        next_page_data: dict[str, str | int] | None = None,
+    ) -> list[dict[str, Any]]:
+        """
+        Return a list of records that match the given query configuration.
+
+        next_page_data is used to return data to the caller.  Pass in an empty dictionary, and it will be populated
+        with the data needed to return the next page of results.  If it is still an empty dictionary when returned,
+        then there is no additional data.
+        """
+        return []
+
+    def validate_pagination_data(self, data: dict[str, Any], case_mapping: Callable[[str], str]) -> str:
+        """
+        Check if the given dictionary is valid pagination data for the background.
+
+        Return a string with an error message, or an empty string if the data is valid
+        """
+        return ""
+
+    def allowed_pagination_keys(self) -> list[str]:
+        """
+        Return the list of allowed keys in the pagination kwargs for the backend.
+
+        It must always return keys in snake_case so that the auto casing system can
+        adjust on the front-end for consistency.
+        """
+        return []
+
+    def documentation_pagination_next_page_response(self, case_mapping: Callable) -> list[Any]:
+        """
+        Return a list of autodoc schema objects.
+
+        It will describe the contents of the `next_page` dictionary
+        in the pagination section of the response
+        """
+        return []
+
+    def documentation_pagination_parameters(self, case_mapping: Callable) -> list[tuple[AutoDocSchema, str]]:
+        """
+        Return a list of autodoc schema objects describing the allowed input keys to set pagination.
+
+        It should return a list of tuples, with each tuple corresponding to an input key.
+        The first element in the tuple should be the schema, and the second should be the description.
+        """
+        return []
+
+    def documentation_pagination_next_page_example(self, case_mapping: Callable) -> dict[str, Any]:
+        """
+        Return an example for next page documentation.
+
+        Returns an example (as a simple dictionary) of what the next_page data in the pagination response
+        should look like
+        """
+        return {}