clear-skies-aws 1.9.18__tar.gz → 1.10.0__tar.gz

{clear_skies_aws-1.9.18 → clear_skies_aws-1.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: clear-skies-aws
-Version: 1.9.18
+Version: 1.10.0
 Summary: clearskies bindings for working in AWS
 License: MIT
 Author: Conor Mancone
@@ -14,8 +14,12 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Provides-Extra: akeyless
 Provides-Extra: ses
+Requires-Dist: akeyless (>=4.0.0,<5.0.0) ; extra == "akeyless"
+Requires-Dist: akeyless-cloud-id (>=0.2.3,<0.3.0) ; extra == "akeyless"
 Requires-Dist: boto3 (>=1.26.148,<2.0.0)
 Requires-Dist: clear-skies (>=1.14.4,<2.0.0)
+Requires-Dist: jinja2 (>=3.1.2,<4.0.0) ; extra == "ses"
+Requires-Dist: types-boto3[dynamodb,sns,sqs] (>=1.38.13,<2.0.0)
 Project-URL: Repository, https://github.com/cmancone/clearskies-aws
 Description-Content-Type: text/markdown
 

{clear_skies_aws-1.9.18 → clear_skies_aws-1.10.0}/pyproject.toml

@@ -2,7 +2,7 @@
 
 [tool.poetry]
 name = "clear-skies-aws"
-version = "1.9.18"
+version = "1.10.0"
 description = "clearskies bindings for working in AWS"
 authors = [
     "Conor Mancone <cmancone@gmail.com>",
@@ -17,18 +17,21 @@ packages = [
 
 [tool.poetry.dependencies]
 python = "^3.10"
-clear-skies = "^1.14.4"
 boto3 = "^1.26.148"
+clear-skies = "^1.14.4"
+types-boto3 = {extras = ["dynamodb", "sns", "sqs"], version = "^1.38.13"}
+akeyless = {version = "^4.0.0", optional = true}
+akeyless-cloud-id = {version = "^0.2.3", optional = true}
+jinja2 = {version = "^3.1.2", optional = true}
 
 [[tool.poetry.source]]
 name = "PyPI"
 priority = "primary"
 
 [tool.poetry.group.dev.dependencies]
+
 pre-commit = "^3.2.2"
-jinja2 = {version = "^3.1.2", optional = true}
-akeyless = {version = "^4.0.0", optional = true}
-akeyless-cloud-id = {version = "^0.2.3", optional = true}
+pytest = "^8.3.5"
 
 [tool.poetry.extras]
 akeyless = ["akeyless-cloud-id", "akeyless"]

{clear_skies_aws-1.9.18 → clear_skies_aws-1.10.0}/src/clearskies_aws/actions/assume_role_test.py

@@ -1,6 +1,9 @@
 import unittest
 from unittest.mock import MagicMock, call
+
 from .assume_role import AssumeRole
+
+
 class AssumeRoleTest(unittest.TestCase):
     def test_with_external_id(self):
         sts = MagicMock()
@@ -18,7 +21,7 @@ class AssumeRoleTest(unittest.TestCase):
         boto3.Session = MagicMock(return_value='MOAR BOTO')
 
         assume_role = AssumeRole(role_arn='aws:arn:role/name', external_id='12345')
-        self.assertEquals('MOAR BOTO', assume_role(boto3))
+        self.assertEqual("MOAR BOTO", assume_role(boto3))
         boto3.client.assert_called_with("sts")
         boto3.Session.assert_called_with(
             aws_access_key_id="access-key",
@@ -54,7 +57,7 @@ class AssumeRoleTest(unittest.TestCase):
             role_session_name="sup",
             duration=7200,
         )
-        self.assertEquals('MOAR BOTO', assume_role("not-boto3"))
+        self.assertEqual("MOAR BOTO", assume_role("not-boto3"))
         boto3.client.assert_called_with("sts")
         boto3.Session.assert_called_with(
             aws_access_key_id="access-key",

clear_skies_aws-1.10.0/src/clearskies_aws/backends/__init__.py

@@ -0,0 +1,12 @@
+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
+
+__all__ = [
+    "DynamoDBBackend",
+    "SqsBackend",
+    "DynamoDBPartiQLBackend",
+    "DynamoDBPartiQLCursor",
+    "DynamoDBConditionParser",
+]

{clear_skies_aws-1.9.18 → clear_skies_aws-1.10.0}/src/clearskies_aws/backends/dynamo_db_backend.py

@@ -1,14 +1,17 @@
-from clearskies.backends.backend import Backend
-from boto3.dynamodb import conditions as dynamodb_conditions
-from decimal import Decimal
-from clearskies.column_types.float import Float
-from clearskies.column_types.integer import Integer
-from clearskies.column_types.boolean import Boolean
-import json
 import base64
+import json
+from decimal import Decimal
 from typing import Any, Callable, Dict, List, Tuple
+
+from boto3.dynamodb import conditions as dynamodb_conditions
 from clearskies import model
 from clearskies.autodoc.schema import String as AutoDocString
+from clearskies.backends.backend import Backend
+from clearskies.column_types.boolean import Boolean
+from clearskies.column_types.float import Float
+from clearskies.column_types.integer import Integer
+
+
 class DynamoDBBackend(Backend):
     """
     DynamoDB is complicated.

{clear_skies_aws-1.9.18 → clear_skies_aws-1.10.0}/src/clearskies_aws/backends/dynamo_db_backend_test.py

@@ -1,12 +1,15 @@
 import unittest
-from unittest.mock import MagicMock
 from collections import OrderedDict
-from types import SimpleNamespace
 from decimal import Decimal
-from .dynamo_db_backend import DynamoDBBackend
+from types import SimpleNamespace
+from unittest.mock import MagicMock
+
 import clearskies
-from ..di import StandardDependencies
 from boto3.dynamodb import conditions as dynamodb_conditions
+
+from ..di import StandardDependencies
+
+
 class User(clearskies.Model):
     def __init__(self, dynamo_db_backend, columns):
         super().__init__(dynamo_db_backend, columns)
@@ -87,24 +90,27 @@ class DynamoDBBackendTest(unittest.TestCase):
         user.save({'name': 'sup', 'age': 5, 'category_id': '1-2-3-4'})
         self.boto3.resource.assert_called_with('dynamodb', region_name='us-east-2')
         self.dynamo_db.Table.assert_called_with('users')
-        self.assertEquals(1, len(self.dynamo_db_table.put_item.call_args_list))
+        self.assertEqual(1, len(self.dynamo_db_table.put_item.call_args_list))
         call = self.dynamo_db_table.put_item.call_args_list[0]
-        self.assertEquals((), call.args)
-        self.assertEquals(1, len(call.kwargs))
+        self.assertEqual((), call.args)
+        self.assertEqual(1, len(call.kwargs))
         self.assertTrue('Item' in call.kwargs)
         saved_data = call.kwargs['Item']
         # we're doing this a bit weird because the UUIDs will generate random values.
         # I could mock it, or I could just be lazy and grab it from the data I was given.
-        self.assertEquals({
-            'id': saved_data['id'],
-            'name': 'sup',
-            'age': 5,
-            'category_id': '1-2-3-4',
-        }, saved_data)
-        self.assertEquals(saved_data['id'], user.id)
-        self.assertEquals(5, user.age)
-        self.assertEquals('1-2-3-4', user.category_id)
-        self.assertEquals('sup', user.name)
+        self.assertEqual(
+            {
+                "id": saved_data["id"],
+                "name": "sup",
+                "age": 5,
+                "category_id": "1-2-3-4",
+            },
+            saved_data,
+        )
+        self.assertEqual(saved_data["id"], user.id)
+        self.assertEqual(5, user.age)
+        self.assertEqual("1-2-3-4", user.category_id)
+        self.assertEqual("sup", user.name)
 
     def test_update(self):
         self.dynamo_db_table.update_item = MagicMock(
@@ -135,10 +141,10 @@ class DynamoDBBackendTest(unittest.TestCase):
             },
             ReturnValues="ALL_NEW",
         )
-        self.assertEquals('1-2-3-4', user.id)
-        self.assertEquals('hello', user.name)
-        self.assertEquals(10, user.age)
-        self.assertEquals('1-2-3-5', user.category_id)
+        self.assertEqual("1-2-3-4", user.id)
+        self.assertEqual("hello", user.name)
+        self.assertEqual(10, user.age)
+        self.assertEqual("1-2-3-5", user.category_id)
 
     def test_delete(self):
         self.dynamo_db_table.delete_item = MagicMock()
@@ -158,24 +164,24 @@ class DynamoDBBackendTest(unittest.TestCase):
         users = self.di.build(Users)
         user = users.where('id=1-2-3-4').first()
         self.assertTrue(user.exists)
-        self.assertEquals('1-2-3-4', user.id)
-        self.assertEquals(10, user.age)
-        self.assertEquals('4-5-6', user.category_id)
-        self.assertEquals(1, len(self.dynamo_db_table.query.call_args_list))
+        self.assertEqual("1-2-3-4", user.id)
+        self.assertEqual(10, user.age)
+        self.assertEqual("4-5-6", user.category_id)
+        self.assertEqual(1, len(self.dynamo_db_table.query.call_args_list))
         call = self.dynamo_db_table.query.call_args_list[0]
-        self.assertEquals(3, len(call.kwargs))
-        self.assertEquals('ALL_ATTRIBUTES', call.kwargs['Select'])
-        self.assertEquals(True, call.kwargs['ScanIndexForward'])
+        self.assertEqual(3, len(call.kwargs))
+        self.assertEqual("ALL_ATTRIBUTES", call.kwargs["Select"])
+        self.assertEqual(True, call.kwargs["ScanIndexForward"])
         key_condition = call.kwargs['KeyConditionExpression']
 
         # dynamodb does not make it easy to verify that the key expression was built properly,
         # and I don't think that mocking will make this any better.  Hoepfully they don't
         # change their library often...
         key_column = key_condition.get_expression()['values'][0]
-        self.assertEquals('id', key_column.name)
+        self.assertEqual("id", key_column.name)
         self.assertTrue(isinstance(key_column, dynamodb_conditions.Key))
-        self.assertEquals('=', key_condition.expression_operator)
-        self.assertEquals('1-2-3-4', key_condition.get_expression()['values'][1])
+        self.assertEqual("=", key_condition.expression_operator)
+        self.assertEqual("1-2-3-4", key_condition.get_expression()["values"][1])
 
     def test_fetch_by_id_with_sort(self):
         self.dynamo_db_table.query = MagicMock(
@@ -187,22 +193,22 @@ class DynamoDBBackendTest(unittest.TestCase):
         )
         users = self.di.build(Users)
         users = users.where('id=1-2-3-4').sort_by('category_id', 'desc').__iter__()
-        self.assertEquals(1, len(self.dynamo_db_table.query.call_args_list))
+        self.assertEqual(1, len(self.dynamo_db_table.query.call_args_list))
         call = self.dynamo_db_table.query.call_args_list[0]
-        self.assertEquals(4, len(call.kwargs))
-        self.assertEquals('ALL_ATTRIBUTES', call.kwargs['Select'])
-        self.assertEquals('id-category_id-index', call.kwargs['IndexName'])
-        self.assertEquals(False, call.kwargs['ScanIndexForward'])
+        self.assertEqual(4, len(call.kwargs))
+        self.assertEqual("ALL_ATTRIBUTES", call.kwargs["Select"])
+        self.assertEqual("id-category_id-index", call.kwargs["IndexName"])
+        self.assertEqual(False, call.kwargs["ScanIndexForward"])
         key_condition = call.kwargs['KeyConditionExpression']
 
         # dynamodb does not make it easy to verify that the key expression was built properly,
         # and I don't think that mocking will make this any better.  Hoepfully they don't
         # change their library often...
         key_column = key_condition.get_expression()['values'][0]
-        self.assertEquals('id', key_column.name)
+        self.assertEqual("id", key_column.name)
         self.assertTrue(isinstance(key_column, dynamodb_conditions.Key))
-        self.assertEquals('=', key_condition.expression_operator)
-        self.assertEquals('1-2-3-4', key_condition.get_expression()['values'][1])
+        self.assertEqual("=", key_condition.expression_operator)
+        self.assertEqual("1-2-3-4", key_condition.get_expression()["values"][1])
 
     def test_fetch_by_secondary_index_twice(self):
         self.dynamo_db_table.query = MagicMock(
@@ -214,12 +220,12 @@ class DynamoDBBackendTest(unittest.TestCase):
         )
         users = self.di.build(Users)
         users = users.where('category_id=1-2-3-4').where('age>10').__iter__()
-        self.assertEquals(1, len(self.dynamo_db_table.query.call_args_list))
+        self.assertEqual(1, len(self.dynamo_db_table.query.call_args_list))
         call = self.dynamo_db_table.query.call_args_list[0]
-        self.assertEquals(4, len(call.kwargs))
-        self.assertEquals('ALL_ATTRIBUTES', call.kwargs['Select'])
-        self.assertEquals('category_id-age-index', call.kwargs['IndexName'])
-        self.assertEquals(True, call.kwargs['ScanIndexForward'])
+        self.assertEqual(4, len(call.kwargs))
+        self.assertEqual("ALL_ATTRIBUTES", call.kwargs["Select"])
+        self.assertEqual("category_id-age-index", call.kwargs["IndexName"])
+        self.assertEqual(True, call.kwargs["ScanIndexForward"])
         key_condition = call.kwargs['KeyConditionExpression']
         self.assertTrue(isinstance(key_condition, dynamodb_conditions.And))
         gt_condition = key_condition.get_expression()['values'][0]
@@ -227,17 +233,17 @@ class DynamoDBBackendTest(unittest.TestCase):
 
         self.assertTrue(isinstance(equal_condition, dynamodb_conditions.Equals))
         key_column = equal_condition.get_expression()['values'][0]
-        self.assertEquals('category_id', key_column.name)
+        self.assertEqual("category_id", key_column.name)
         self.assertTrue(isinstance(key_column, dynamodb_conditions.Key))
-        self.assertEquals('=', equal_condition.expression_operator)
-        self.assertEquals('1-2-3-4', equal_condition.get_expression()['values'][1])
+        self.assertEqual("=", equal_condition.expression_operator)
+        self.assertEqual("1-2-3-4", equal_condition.get_expression()["values"][1])
 
         self.assertTrue(isinstance(gt_condition, dynamodb_conditions.GreaterThan))
         key_column = gt_condition.get_expression()['values'][0]
-        self.assertEquals('age', key_column.name)
+        self.assertEqual("age", key_column.name)
         self.assertTrue(isinstance(key_column, dynamodb_conditions.Key))
-        self.assertEquals('>', gt_condition.expression_operator)
-        self.assertEquals(Decimal('10'), gt_condition.get_expression()['values'][1])
+        self.assertEqual(">", gt_condition.expression_operator)
+        self.assertEqual(Decimal("10"), gt_condition.get_expression()["values"][1])
 
     def test_index_and_scan(self):
         self.dynamo_db_table.query = MagicMock(
@@ -249,27 +255,27 @@ class DynamoDBBackendTest(unittest.TestCase):
         )
         users = self.di.build(Users)
         users = users.where('category_id=1-2-3-4').where('age is not null').__iter__()
-        self.assertEquals(1, len(self.dynamo_db_table.query.call_args_list))
+        self.assertEqual(1, len(self.dynamo_db_table.query.call_args_list))
         call = self.dynamo_db_table.query.call_args_list[0]
-        self.assertEquals(5, len(call.kwargs))
-        self.assertEquals('ALL_ATTRIBUTES', call.kwargs['Select'])
-        self.assertEquals('category_id-name-index', call.kwargs['IndexName'])
-        self.assertEquals(True, call.kwargs['ScanIndexForward'])
+        self.assertEqual(5, len(call.kwargs))
+        self.assertEqual("ALL_ATTRIBUTES", call.kwargs["Select"])
+        self.assertEqual("category_id-name-index", call.kwargs["IndexName"])
+        self.assertEqual(True, call.kwargs["ScanIndexForward"])
 
         # our key condition should be an equal search on category_id
         key_condition = call.kwargs['KeyConditionExpression']
         key_column = key_condition.get_expression()['values'][0]
-        self.assertEquals('category_id', key_column.name)
+        self.assertEqual("category_id", key_column.name)
         self.assertTrue(isinstance(key_column, dynamodb_conditions.Key))
-        self.assertEquals('=', key_condition.expression_operator)
-        self.assertEquals('1-2-3-4', key_condition.get_expression()['values'][1])
+        self.assertEqual("=", key_condition.expression_operator)
+        self.assertEqual("1-2-3-4", key_condition.get_expression()["values"][1])
 
         # and we should have a FilterExpression which is an 'is not null' condition
         filter_condition = call.kwargs['FilterExpression']
         key_column = filter_condition.get_expression()['values'][0]
-        self.assertEquals('age', key_column.name)
+        self.assertEqual("age", key_column.name)
         self.assertTrue(isinstance(key_column, dynamodb_conditions.Attr))
-        self.assertEquals('attribute_not_exists', filter_condition.expression_operator)
+        self.assertEqual("attribute_not_exists", filter_condition.expression_operator)
 
     def test_scan_only(self):
         self.dynamo_db_table.scan = MagicMock(
@@ -281,14 +287,14 @@ class DynamoDBBackendTest(unittest.TestCase):
         )
         users = self.di.build(Users)
         users = users.where('category_id>1-2-3-4').__iter__()
-        self.assertEquals(1, len(self.dynamo_db_table.scan.call_args_list))
+        self.assertEqual(1, len(self.dynamo_db_table.scan.call_args_list))
         call = self.dynamo_db_table.scan.call_args_list[0]
-        self.assertEquals(2, len(call.kwargs))
-        self.assertEquals('ALL_ATTRIBUTES', call.kwargs['Select'])
+        self.assertEqual(2, len(call.kwargs))
+        self.assertEqual("ALL_ATTRIBUTES", call.kwargs["Select"])
 
         # and we should have a FilterExpression which is an 'is not null' condition
         filter_condition = call.kwargs['FilterExpression']
         key_column = filter_condition.get_expression()['values'][0]
-        self.assertEquals('category_id', key_column.name)
+        self.assertEqual("category_id", key_column.name)
         self.assertTrue(isinstance(key_column, dynamodb_conditions.Attr))
-        self.assertEquals('>', filter_condition.expression_operator)
+        self.assertEqual(">", filter_condition.expression_operator)