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

clearskies_aws/contexts/lambda_http_gateway.py

@@ -1,30 +0,0 @@
-from ..input_outputs import LambdaHTTPGateway as LambdaHTTPGatewayInputOutput
-from ..di import StandardDependencies
-from clearskies.contexts.build_context import build_context
-from clearskies.contexts.context import Context
-class LambdaHTTPGateway(Context):
-    def __init__(self, di):
-        super().__init__(di)
-
-    def __call__(self, event, context):
-        if self.handler is None:
-            raise ValueError("Cannot execute LambdaHTTPGateway context without first configuring it")
-
-        return self.handler(LambdaHTTPGatewayInputOutput(event, context))
-def lambda_http_gateway(
-    application,
-    di_class=StandardDependencies,
-    bindings=None,
-    binding_classes=None,
-    binding_modules=None,
-    additional_configs=None,
-):
-    return build_context(
-        LambdaHTTPGateway,
-        application,
-        di_class=di_class,
-        bindings=bindings,
-        binding_classes=binding_classes,
-        binding_modules=binding_modules,
-        additional_configs=additional_configs,
-    )

clearskies_aws/contexts/lambda_sqs_standard_partial_batch_test.py

@@ -1,66 +0,0 @@
-import json
-import unittest
-from types import SimpleNamespace
-from unittest.mock import MagicMock, call
-
-from .lambda_sqs_standard_partial_batch import lambda_sqs_standard_partial_batch
-
-
-class LambdaSqsStandardPartialBatchTest(unittest.TestCase):
-    def setUp(self):
-        self.calls = []
-
-    def my_callable(self, request_data):
-        if 'boom' in request_data:
-            raise ValueError('oops')
-        self.calls.append(request_data)
-
-    def test_simple_execution(self):
-        sqs_handler = lambda_sqs_standard_partial_batch(self.my_callable)
-        sqs_handler(
-            {
-                'Records': [
-                    {
-                        'messageId': '1-2-3-4',
-                        'body': json.dumps({'hey': 'sup'}),
-                    },
-                    {
-                        'messageId': '2-3-4-5',
-                        'body': json.dumps({'cool': 'yo'}),
-                    },
-                ]
-            },
-            {},
-        )
-        self.assertEqual(
-            [
-                {"hey": "sup"},
-                {"cool": "yo"},
-            ],
-            self.calls,
-        )
-
-    def test_with_failure(self):
-        sqs_handler = lambda_sqs_standard_partial_batch(self.my_callable)
-        results = sqs_handler({
-            'Records': [
-                {
-                    'messageId': '1-2-3-4',
-                    'body': json.dumps({'hey': 'sup'}),
-                },
-                {
-                    'messageId': '2-3-4-5',
-                    'body': json.dumps({'boom': 'yo'}),
-                },
-            ]
-        }, {})
-        self.assertEqual(
-            [
-                {"hey": "sup"},
-            ],
-            self.calls,
-        )
-        self.assertEqual(
-            {"batchItemFailures": [{"itemIdentifier": "2-3-4-5"}]},
-            results,
-        )

clearskies_aws/contexts/wsgi.py

@@ -1,19 +0,0 @@
-from ..di import StandardDependencies
-from clearskies.contexts.wsgi import WSGI, build_context
-def wsgi(
-    application,
-    di_class=StandardDependencies,
-    bindings=None,
-    binding_classes=None,
-    binding_modules=None,
-    additional_configs=None,
-):
-    return build_context(
-        WSGI,
-        application,
-        di_class=di_class,
-        bindings=bindings,
-        binding_classes=binding_classes,
-        binding_modules=binding_modules,
-        additional_configs=additional_configs,
-    )

clearskies_aws/di/standard_dependencies.py

@@ -1,60 +0,0 @@
-from types import ModuleType
-
-import boto3 as boto3_module
-from boto3.session import Session as Boto3Session
-from clearskies import Environment
-from clearskies.di import StandardDependencies as DefaultStandardDependencies
-
-from ..backends import (
-    DynamoDBBackend,
-    DynamoDBPartiQLBackend,
-    DynamoDBPartiQLCursor,
-    SqsBackend,
-)
-from ..secrets import ParameterStore
-
-
-class StandardDependencies(DefaultStandardDependencies):
-
-    def provide_dynamo_db_parti_ql_cursor(
-        self, boto3_session: Boto3Session
-    ) -> DynamoDBPartiQLCursor:
-        return DynamoDBPartiQLCursor(boto3_session)
-
-    def provide_dynamo_db_backend(
-        self, boto3: ModuleType, environment: Environment
-    ) -> DynamoDBBackend:
-        return DynamoDBBackend(boto3, environment)
-
-    def provide_dynamo_db_parti_ql_backend(
-        self, dynamo_db_parti_ql_cursor: DynamoDBPartiQLCursor, environment: Environment
-    ) -> DynamoDBPartiQLBackend:
-        return DynamoDBPartiQLBackend(dynamo_db_parti_ql_cursor)
-
-    def provide_sqs_backend(
-        self, boto3: ModuleType, environment: Environment
-    ) -> SqsBackend:
-        return SqsBackend(boto3, environment)
-
-    def provide_boto3(self) -> ModuleType:
-        import boto3
-        return boto3
-
-    def provide_secrets(
-        self, boto3: ModuleType, environment: Environment
-    ) -> ParameterStore:
-        # This is just here so that we can auto-inject the secrets into the environment without having
-        # to force the developer to define a secrets manager
-        return ParameterStore(boto3, environment)
-
-    def provide_boto3_session(
-        self, boto3: ModuleType, environment: Environment
-    ) -> boto3_module.session.Session:
-
-        if not environment.get("AWS_REGION", True):
-            raise ValueError(
-                "To use AWS Session you must use set AWS_REGION in the .env file or an environment variable"
-            )
-
-        session = boto3.session.Session(region_name=environment.get("AWS_REGION", True))
-        return session

clearskies_aws/handlers/simple_body_routing.py

@@ -1,39 +0,0 @@
-import clearskies
-
-
-class SimpleBodyRouting(clearskies.handlers.Routing):
-    def __init__(self, di):
-        super().__init__(di)
-
-    _configuration_defaults = {
-        "routes": {},
-        "route_key": "route",
-    }
-
-    def handler_classes(self, configuration):
-        # not actually used but required by base
-        return []
-
-    def _check_configuration(self, configuration):
-        for config_name in ["route_key", "routes"]:
-            if not configuration.get(config_name):
-                raise KeyError(f"Missing required configuration for SimpleBodyRouting handler: '{config_name}'")
-        if not isinstance(configuration["routes"], dict):
-            raise ValueError(f"COnfiguration 'routes' for handler SimpleBodyRouting must be a dictionary, but instead I got something else.")
-
-    def handle(self, input_output):
-        body = input_output.json_body(required=True)
-        if not body or not body.get(self.configuration("route_key")):
-            return self.error(input_output, "Not Found", 404)
-
-        route = body[self.configuration("route_key")]
-        if route not in self.configuration("routes"):
-            return self.error(input_output, "Not Found", 404)
-        return input_output.respond(self._di.call_function(
-            self.configuration("routes")[route],
-            request_data=body,
-            **input_output.context_specifics(),
-        ), 200)
-
-    def documentation(self):
-        return []

clearskies_aws/input_outputs/lambda_api_gateway_test.py

@@ -1,87 +0,0 @@
-import unittest
-from collections import OrderedDict
-
-from .lambda_api_gateway import LambdaAPIGateway
-
-
-class LambdaAPIGatewayTest(unittest.TestCase):
-    dummy_event = {
-        'httpMethod': 'GET',
-        'path': '/test',
-        'resource': 'bob',
-        'queryStringParameters': {
-            'q': 'hey',
-            'bob': 'sup'
-        },
-        'pathParameters': None,
-        'headers': {
-            'Content-Type': 'application/json'
-        },
-    }
-
-    def test_respond(self):
-        aws_lambda = LambdaAPIGateway(self.dummy_event, {})
-        aws_lambda.set_headers({'bob': 'hey', 'jane': 'kay'})
-        aws_lambda.set_header('hey', 'sup')
-        aws_lambda.clear_header('bob')
-        response = aws_lambda.respond({'some': 'data'}, 200)
-        self.assertEqual(
-            {
-                "isBase64Encoded": False,
-                "statusCode": 200,
-                "headers": OrderedDict(
-                    [
-                        ("JANE", "kay"),
-                        ("HEY", "sup"),
-                        ("CONTENT-TYPE", "application/json; charset=UTF-8"),
-                    ]
-                ),
-                "body": '{"some": "data"}',
-            },
-            response,
-        )
-
-    def test_headers(self):
-        aws_lambda = LambdaAPIGateway({
-            **self.dummy_event,
-            **{
-                'headers': {
-                    'Content-Type': 'application/json',
-                    'AUTHORIZATION': 'hey',
-                    'X-Auth': 'asdf',
-                }
-            }
-        }, {})
-        self.assertEqual("hey", aws_lambda.get_request_header("authorizatiON"))
-        self.assertEqual("asdf", aws_lambda.get_request_header("x-auth"))
-        self.assertTrue(aws_lambda.has_request_header('authorization'))
-        self.assertTrue(aws_lambda.has_request_header('x-auth'))
-        self.assertFalse(aws_lambda.has_request_header('bearer'))
-
-    def test_body_plain(self):
-        aws_lambda = LambdaAPIGateway({**self.dummy_event, **{'body': '{"hey": "sup"}', 'isBase64Encoded': False}}, {})
-
-        self.assertEqual({"hey": "sup"}, aws_lambda.json_body())
-        self.assertEqual('{"hey": "sup"}', aws_lambda.get_body())
-        self.assertTrue(aws_lambda.has_body())
-
-    def test_body_base64(self):
-        aws_lambda = LambdaAPIGateway({
-            **self.dummy_event,
-            **{
-                'body': 'eyJoZXkiOiAic3VwIn0=',
-                'isBase64Encoded': True
-            }
-        }, {})
-
-        self.assertEqual({"hey": "sup"}, aws_lambda.json_body())
-        self.assertEqual('{"hey": "sup"}', aws_lambda.get_body())
-        self.assertTrue(aws_lambda.has_body())
-
-    def test_path(self):
-        aws_lambda = LambdaAPIGateway(self.dummy_event, {})
-        self.assertEqual("/test", aws_lambda.get_path_info())
-
-    def test_query_string(self):
-        aws_lambda = LambdaAPIGateway(self.dummy_event, {})
-        self.assertEqual("q=hey&bob=sup", aws_lambda.get_query_string())

clearskies_aws/input_outputs/lambda_elb.py

@@ -1,21 +0,0 @@
-from .lambda_api_gateway import LambdaAPIGateway
-class LambdaELB(LambdaAPIGateway):
-    _event = None
-    _context = None
-    _request_headers = None
-    _request_method = None
-    _path = None
-    _query_parameters = None
-
-    def __init__(self, event, context):
-        self._event = event
-        self._context = context
-        self._request_method = event.get('httpMethod', 'GET').upper()
-        self._path = event.get('path', '/')
-        self._query_parameters = event.get('queryStringParameters', {})
-        self._request_headers = {}
-        for (key, value) in event.get('headers', {}).items():
-            self._request_headers[key.lower()] = value
-
-    def get_client_ip(self):
-        return self.get_request_header('x-forwarded-for')

clearskies_aws/input_outputs/lambda_http_gateway.py

@@ -1,12 +0,0 @@
-from .lambda_api_gateway import LambdaAPIGateway
-class LambdaHTTPGateway(LambdaAPIGateway):
-    def __init__(self, event, context):
-        self._event = event
-        self._context = context
-        self._path = event.get('requestContext', {}).get('http', {}).get('path')
-        self._request_method = event.get('requestContext', {}).get('http', {}).get('method').upper()
-        self._query_parameters = event['queryStringParameters'] if event['queryStringParameters'] is not None else {}
-        self._path_parameters = event['pathParameters']
-        self._request_headers = {}
-        for (key, value) in event['headers'].items():
-            self._request_headers[key.lower()] = value

clearskies_aws/secrets/parameter_store_test.py

@@ -1,18 +0,0 @@
-import unittest
-from types import SimpleNamespace
-from unittest.mock import MagicMock
-
-from .parameter_store import ParameterStore
-
-
-class ParameterStoreTest(unittest.TestCase):
-    def setUp(self):
-        self.environment = SimpleNamespace(get=MagicMock(return_value='us-east-1'))
-
-    def test_get(self):
-        ssm = SimpleNamespace(get_parameter=MagicMock(return_value={'Parameter': {'Value': 'sup'}}))
-        boto3 = SimpleNamespace(client=MagicMock(return_value=ssm))
-        parameter_store = ParameterStore(boto3, self.environment)
-        self.assertEqual("sup", parameter_store.get("/my/item"))
-        ssm.get_parameter.assert_called_with(Name='/my/item', WithDecryption=True)
-        boto3.client.assert_called_with('ssm', region_name='us-east-1')

clearskies_aws/secrets/secrets_manager_test.py

@@ -1,18 +0,0 @@
-import unittest
-from types import SimpleNamespace
-from unittest.mock import MagicMock
-
-from .secrets_manager import SecretsManager
-
-
-class SecretsManagerTest(unittest.TestCase):
-    def setUp(self):
-        self.environment = SimpleNamespace(get=MagicMock(return_value='us-east-1'))
-
-    def test_get(self):
-        secretsmanager = SimpleNamespace(get_secret_value=MagicMock(return_value={'SecretString': 'sup'}))
-        boto3 = SimpleNamespace(client=MagicMock(return_value=secretsmanager))
-        secrets_manager = SecretsManager(boto3, self.environment)
-        self.assertEqual("sup", secrets_manager.get("/my/item"))
-        secretsmanager.get_secret_value.assert_called_with(SecretId='/my/item')
-        boto3.client.assert_called_with('secretsmanager', region_name='us-east-1')

clearskies_aws/web_socket_connection_model.py

@@ -1,43 +0,0 @@
-from abc import abstractmethod
-import json
-
-import clearskies
-
-
-class WebSocketConnectionModel(clearskies.Model):
-
-    id_column_name = "connection_id"
-
-    def __init__(self, backend, columns, boto3, input_output):
-        super().__init__(backend, columns)
-        self._boto3 = boto3
-        self._input_output = input_output
-
-    def _build_model(self):
-        model_class = self.model_class()
-        return model_class(self._backend, self._columns, self._boto3, self._input_output)
-
-    def send(self, message):
-        if not self.exists:
-            raise ValueError("Cannot send message to non-existent connection.")
-        if not self.data.get("connection_id"):
-            raise ValueError(
-                f"Hmmm... I couldn't find the connection id for the {self.__class__.__name__}.  I'm picky about id column names.  Can you please make sure I have a column called connection_id and that it contains the connection id?"
-            )
-
-        event = self._input_output.context_specifics()["event"]
-        domain = event.get("requestContext", {}).get("domainName")
-        stage = event.get("requestContext", {}).get("stage")
-        # only include the stage if we're using the default AWS domain - not with a custom domain
-        if ".amazonaws.com" in domain:
-            endpoint_url = f"https://{domain}/{stage}"
-        else:
-            endpoint_url = f"https://{domain}"
-        api_gateway = self._boto3.client("apigatewaymanagementapi", endpoint_url=endpoint_url)
-
-        bytes_message = json.dumps(message).encode("utf-8")
-        try:
-            response = api_gateway.post_to_connection(Data=bytes_message, ConnectionId=self.connection_id)
-        except api_gateway.exceptions.GoneException:
-            self.delete()
-        return response

clearskies_aws/{handlers → endpoints}/__init__.py

@@ -1,2 +1,2 @@
-from .simple_body_routing import SimpleBodyRouting
 from .secrets_manager_rotation import SecretsManagerRotation
+from .simple_body_routing import SimpleBodyRouting