m

Author: Lucas McDonald

.github/workflows/ci_static_analysis_python.yml

@@ -73,5 +73,4 @@ jobs:
       - name: Run static analysis
         working-directory: ./DynamoDbEncryption/runtimes/python
         run: |
-          tox -e ruff
-          tox -e black-check
+          tox -e lint-check

DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/internal/client_to_resource.py

@@ -28,8 +28,10 @@ def condition_handler(self, expression_key, request):
         condition = request[expression_key]
 
         # This conversion in client_to_resource does not update ExpressionAttributeNames or ExpressionAttributeValues.
-        # However, resource_to_client condition_handler may add new ExpressionAttributeNames and ExpressionAttributeValues.
-        # Smithy-generated code expects condition_handlers to return ExpressionAttributeNames and ExpressionAttributeValues,
+        # However, resource_to_client condition_handler may add new ExpressionAttributeNames and
+        # ExpressionAttributeValues.
+        # Smithy-generated code expects condition_handlers to return ExpressionAttributeNames and
+        # ExpressionAttributeValues,
         # expecting empty dicts if there are none.
         try:
             names = request["ExpressionAttributeNames"]
@@ -88,7 +90,7 @@ def delete_item_request(self, delete_item_request):
         if self.delete_table_name:
             del out["TableName"]
         return out
-    
+
     def delete_item_response(self, delete_item_response):
         return self.boto3_converter.DeleteItemOutput(delete_item_response)
 
@@ -98,7 +100,7 @@ def update_item_request(self, update_item_request):
         if self.delete_table_name:
             del out["TableName"]
         return out
-    
+
     def update_item_response(self, update_item_response):
         return self.boto3_converter.UpdateItemOutput(update_item_response)
 

DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/internal/condition_expression_builder.py

@@ -17,22 +17,23 @@ class InternalDBESDKDynamoDBConditionExpressionBuilder:
     def __init__(self):
         self._name_count = 0
         self._value_count = 0
-        self._name_placeholder = 'n'
-        self._value_placeholder = 'v'
+        self._name_placeholder = "n"
+        self._value_placeholder = "v"
 
     def _get_name_placeholder(self):
-        return '#' + self._name_placeholder + str(self._name_count)
+        return "#" + self._name_placeholder + str(self._name_count)
 
     def _get_value_placeholder(self):
-        return ':' + self._value_placeholder + str(self._value_count)
+        return ":" + self._value_placeholder + str(self._value_count)
 
     def reset(self):
         """Resets the placeholder name and values"""
         self._name_count = 0
         self._value_count = 0
 
     def build_expression(self, condition, is_key_condition=False):
-        """Builds the condition expression and the dictionary of placeholders.
+        """
+        Builds the condition expression and the dictionary of placeholders.
 
         :type condition: ConditionBase
         :param condition: A condition to be built into a condition expression
@@ -75,7 +76,7 @@ def _build_expression(
     ):
         expression_dict = condition.get_expression()
         replaced_values = []
-        for value in expression_dict['values']:
+        for value in expression_dict["values"]:
             # Build the necessary placeholders for that value.
             # Placeholders are built for both attribute names and values.
             replaced_value = self._build_expression_component(
@@ -88,9 +89,7 @@ def _build_expression(
             replaced_values.append(replaced_value)
         # Fill out the expression using the operator and the
         # values that have been replaced with placeholders.
-        return expression_dict['format'].format(
-            *replaced_values, operator=expression_dict['operator']
-        )
+        return expression_dict["format"].format(*replaced_values, operator=expression_dict["operator"])
 
     def _build_expression_component(
         self,
@@ -115,27 +114,23 @@ def _build_expression_component(
         elif isinstance(value, AttributeBase):
             if is_key_condition and not isinstance(value, Key):
                 raise DynamoDBNeedsKeyConditionError(
-                    f'Attribute object {value.name} is of type {type(value)}. '
-                    f'KeyConditionExpression only supports Attribute objects '
-                    f'of type Key'
+                    f"Attribute object {value.name} is of type {type(value)}. "
+                    f"KeyConditionExpression only supports Attribute objects "
+                    f"of type Key"
                 )
-            return self._build_name_placeholder(
-                value, attribute_name_placeholders
-            )
+            return self._build_name_placeholder(value, attribute_name_placeholders)
         # If it is anything else, we treat it as a value and thus placeholders
         # are needed for the value.
         else:
-            return self._build_value_placeholder(
-                value, attribute_value_placeholders, has_grouped_values
-            )
+            return self._build_value_placeholder(value, attribute_value_placeholders, has_grouped_values)
 
     def _build_name_placeholder(self, value, attribute_name_placeholders):
         attribute_name = value.name
         # Figure out which parts of the attribute name that needs replacement.
         attribute_name_parts = ATTR_NAME_REGEX.findall(attribute_name)
 
         # Add a temporary placeholder for each of these parts.
-        placeholder_format = ATTR_NAME_REGEX.sub('%s', attribute_name)
+        placeholder_format = ATTR_NAME_REGEX.sub("%s", attribute_name)
         str_format_args = []
         for part in attribute_name_parts:
             name_placeholder = self._get_name_placeholder()
@@ -146,9 +141,7 @@ def _build_name_placeholder(self, value, attribute_name_placeholders):
         # Replace the temporary placeholders with the designated placeholders.
         return placeholder_format % tuple(str_format_args)
 
-    def _build_value_placeholder(
-        self, value, attribute_value_placeholders, has_grouped_values=False
-    ):
+    def _build_value_placeholder(self, value, attribute_value_placeholders, has_grouped_values=False):
         # If the values are grouped, we need to add a placeholder for
         # each element inside of the actual value.
         if has_grouped_values:
@@ -161,7 +154,7 @@ def _build_value_placeholder(
             # Assuming the values are grouped by parenthesis.
             # IN is the currently the only one that uses this so it maybe
             # needed to be changed in future.
-            return '(' + ', '.join(placeholder_list) + ')'
+            return "(" + ", ".join(placeholder_list) + ")"
         # Otherwise, treat the value as a single value that needs only
         # one placeholder.
         else:

DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/internal/resource_to_client.py

@@ -3,8 +3,8 @@
 from aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.boto3_conversions import (
     InternalBoto3DynamoDBFormatConverter,
 )
-from boto3.dynamodb.types import TypeSerializer
 from boto3.dynamodb.conditions import ConditionExpressionBuilder
+from boto3.dynamodb.types import TypeSerializer
 
 
 class ResourceShapeToClientShapeConverter:
@@ -43,10 +43,12 @@ def condition_handler(self, expression_key, request):
             hasattr(condition_expression, "__module__")
             and condition_expression.__module__ == "boto3.dynamodb.conditions"
         ):
-            built_condition_expression = self.expression_builder.build_expression(
-                condition_expression
+            built_condition_expression = self.expression_builder.build_expression(condition_expression)
+            return (
+                built_condition_expression.condition_expression,
+                built_condition_expression.attribute_name_placeholders,
+                built_condition_expression.attribute_value_placeholders,
             )
-            return built_condition_expression.condition_expression, built_condition_expression.attribute_name_placeholders, built_condition_expression.attribute_value_placeholders
         else:
             return condition_expression, existing_expression_attribute_names, existing_expression_attribute_values
 

DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb/aws_sdk_to_dafny.py

@@ -25,9 +25,7 @@ def com_amazonaws_dynamodb_AttributeValue(native_input):
                 "".join(
                     [
                         chr(int.from_bytes(pair, "big"))
-                        for pair in zip(
-                            *[iter(native_input["S"].encode("utf-16-be"))] * 2
-                        )
+                        for pair in zip(*[iter(native_input["S"].encode("utf-16-be"))] * 2)
                     ]
                 )
             )
@@ -38,9 +36,7 @@ def com_amazonaws_dynamodb_AttributeValue(native_input):
                 "".join(
                     [
                         chr(int.from_bytes(pair, "big"))
-                        for pair in zip(
-                            *[iter(native_input["N"].encode("utf-16-be"))] * 2
-                        )
+                        for pair in zip(*[iter(native_input["N"].encode("utf-16-be"))] * 2)
                     ]
                 )
             )
@@ -55,9 +51,7 @@ def com_amazonaws_dynamodb_AttributeValue(native_input):
                         "".join(
                             [
                                 chr(int.from_bytes(pair, "big"))
-                                for pair in zip(
-                                    *[iter(list_element.encode("utf-16-be"))] * 2
-                                )
+                                for pair in zip(*[iter(list_element.encode("utf-16-be"))] * 2)
                             ]
                         )
                     )
@@ -73,9 +67,7 @@ def com_amazonaws_dynamodb_AttributeValue(native_input):
                         "".join(
                             [
                                 chr(int.from_bytes(pair, "big"))
-                                for pair in zip(
-                                    *[iter(list_element.encode("utf-16-be"))] * 2
-                                )
+                                for pair in zip(*[iter(list_element.encode("utf-16-be"))] * 2)
                             ]
                         )
                     )
@@ -84,19 +76,14 @@ def com_amazonaws_dynamodb_AttributeValue(native_input):
             )
         )
     elif "BS" in native_input.keys():
-        AttributeValue_union_value = AttributeValue_BS(
-            Seq([Seq(list_element) for list_element in native_input["BS"]])
-        )
+        AttributeValue_union_value = AttributeValue_BS(Seq([Seq(list_element) for list_element in native_input["BS"]]))
     elif "M" in native_input.keys():
         AttributeValue_union_value = AttributeValue_M(
             Map(
                 {
                     Seq(
                         "".join(
-                            [
-                                chr(int.from_bytes(pair, "big"))
-                                for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)
-                            ]
+                            [chr(int.from_bytes(pair, "big")) for pair in zip(*[iter(key.encode("utf-16-be"))] * 2)]
                         )
                     ): aws_cryptography_internal_dynamodb.smithygenerated.com_amazonaws_dynamodb.aws_sdk_to_dafny.com_amazonaws_dynamodb_AttributeValue(
                         value
@@ -121,8 +108,6 @@ def com_amazonaws_dynamodb_AttributeValue(native_input):
     elif "BOOL" in native_input.keys():
         AttributeValue_union_value = AttributeValue_BOOL(native_input["BOOL"])
     else:
-        raise ValueError(
-            "No recognized union value in union type: " + str(native_input)
-        )
+        raise ValueError("No recognized union value in union type: " + str(native_input))
 
     return AttributeValue_union_value

DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb/client.py

@@ -107,9 +107,7 @@ def _execute_operation(
         operation_name: str,
     ) -> Output:
         try:
-            return self._handle_execution(
-                input, plugins, serialize, deserialize, config, operation_name
-            )
+            return self._handle_execution(input, plugins, serialize, deserialize, config, operation_name)
         except Exception as e:
             # Make sure every exception that we throw is an instance of ServiceError so
             # customers can reliably catch everything we throw.
@@ -173,9 +171,7 @@ def _handle_execution(
                 interceptor.read_before_serialization(context)
 
             # Step 4: Serialize the request
-            context_with_transport_request = cast(
-                InterceptorContext[Input, None, DafnyRequest, None], context
-            )
+            context_with_transport_request = cast(InterceptorContext[Input, None, DafnyRequest, None], context)
             context_with_transport_request._transport_request = serialize(
                 context_with_transport_request.request, config
             )
@@ -186,8 +182,8 @@ def _handle_execution(
 
             # Step 6: Invoke modify_before_retry_loop
             for interceptor in interceptors:
-                context_with_transport_request._transport_request = (
-                    interceptor.modify_before_retry_loop(context_with_transport_request)
+                context_with_transport_request._transport_request = interceptor.modify_before_retry_loop(
+                    context_with_transport_request
                 )
 
             # Step 7: Acquire the retry token.
@@ -237,9 +233,7 @@ def _handle_execution(
         # The response will be set either with the modeled output or an exception. The
         # transport_request and transport_response may be set or None.
         execution_context = cast(
-            InterceptorContext[
-                Input, Output, DafnyRequest | None, DafnyResponse | None
-            ],
+            InterceptorContext[Input, Output, DafnyRequest | None, DafnyResponse | None],
             context,
         )
         return self._finalize_execution(interceptors, execution_context)
@@ -261,14 +255,10 @@ def _handle_attempt(
             if config.dafnyImplInterface.impl is None:
                 raise Exception("No impl found on the operation config.")
 
-            context_with_response = cast(
-                InterceptorContext[Input, None, DafnyRequest, DafnyResponse], context
-            )
+            context_with_response = cast(InterceptorContext[Input, None, DafnyRequest, DafnyResponse], context)
 
-            context_with_response._transport_response = (
-                config.dafnyImplInterface.handle_request(
-                    input=context_with_response.transport_request
-                )
+            context_with_response._transport_response = config.dafnyImplInterface.handle_request(
+                input=context_with_response.transport_request
             )
 
             # Step 7n: Invoke read_after_transmit
@@ -277,8 +267,8 @@ def _handle_attempt(
 
             # Step 7o: Invoke modify_before_deserialization
             for interceptor in interceptors:
-                context_with_response._transport_response = (
-                    interceptor.modify_before_deserialization(context_with_response)
+                context_with_response._transport_response = interceptor.modify_before_deserialization(
+                    context_with_response
                 )
 
             # Step 7p: Invoke read_before_deserialization
@@ -290,9 +280,7 @@ def _handle_attempt(
                 InterceptorContext[Input, Output, DafnyRequest, DafnyResponse],
                 context_with_response,
             )
-            context_with_output._response = deserialize(
-                context_with_output._transport_response, config
-            )
+            context_with_output._response = deserialize(context_with_output._transport_response, config)
 
             # Step 7r: Invoke read_after_deserialization
             for interceptor in interceptors:
@@ -318,9 +306,7 @@ def _finalize_attempt(
         # Step 7s: Invoke modify_before_attempt_completion
         try:
             for interceptor in interceptors:
-                context._response = interceptor.modify_before_attempt_completion(
-                    context
-                )
+                context._response = interceptor.modify_before_attempt_completion(context)
         except Exception as e:
             context._response = e
 
@@ -336,9 +322,7 @@ def _finalize_attempt(
     def _finalize_execution(
         self,
         interceptors: list[Interceptor[Input, Output, DafnyRequest, DafnyResponse]],
-        context: InterceptorContext[
-            Input, Output, DafnyRequest | None, DafnyResponse | None
-        ],
+        context: InterceptorContext[Input, Output, DafnyRequest | None, DafnyResponse | None],
     ) -> Output:
         try:
             # Step 9: Invoke modify_before_completion

DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/smithygenerated/aws_cryptography_dbencryptionsdk_dynamodb/dafny_to_aws_sdk.py

@@ -21,40 +21,30 @@ def com_amazonaws_dynamodb_AttributeValue(dafny_input):
     # Convert AttributeValue
     if isinstance(dafny_input, AttributeValue_S):
         AttributeValue_union_value = {
-            "S": b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.S).decode(
-                "utf-16-be"
-            )
+            "S": b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.S).decode("utf-16-be")
         }
     elif isinstance(dafny_input, AttributeValue_N):
         AttributeValue_union_value = {
-            "N": b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.N).decode(
-                "utf-16-be"
-            )
+            "N": b"".join(ord(c).to_bytes(2, "big") for c in dafny_input.N).decode("utf-16-be")
         }
     elif isinstance(dafny_input, AttributeValue_B):
         AttributeValue_union_value = {"B": bytes(dafny_input.B)}
     elif isinstance(dafny_input, AttributeValue_SS):
         AttributeValue_union_value = {
             "SS": [
-                b"".join(ord(c).to_bytes(2, "big") for c in list_element).decode(
-                    "utf-16-be"
-                )
+                b"".join(ord(c).to_bytes(2, "big") for c in list_element).decode("utf-16-be")
                 for list_element in dafny_input.SS
             ]
         }
     elif isinstance(dafny_input, AttributeValue_NS):
         AttributeValue_union_value = {
             "NS": [
-                b"".join(ord(c).to_bytes(2, "big") for c in list_element).decode(
-                    "utf-16-be"
-                )
+                b"".join(ord(c).to_bytes(2, "big") for c in list_element).decode("utf-16-be")
                 for list_element in dafny_input.NS
             ]
         }
     elif isinstance(dafny_input, AttributeValue_BS):
-        AttributeValue_union_value = {
-            "BS": [bytes(list_element) for list_element in dafny_input.BS]
-        }
+        AttributeValue_union_value = {"BS": [bytes(list_element) for list_element in dafny_input.BS]}
     elif isinstance(dafny_input, AttributeValue_M):
         AttributeValue_union_value = {
             "M": {