wip

Author: lucasmcdonald3

DynamoDbEncryption/runtimes/python/src/aws_database_encryption_sdk/encryptor/table.py

@@ -148,15 +148,22 @@ def scan(self, **kwargs):
         return response
 
     def query(self, **kwargs):
+        print(f"query {kwargs=}")
         input_transform_input = self._resource_shape_to_client_shape_converter.query_request(kwargs)
+
+        print(f"query {input_transform_input=}")
         input_transform_output = self._transformer.query_input_transform(
             QueryInputTransformInput(
                 sdk_input = input_transform_input
             )
         ).transformed_input
 
+        print(f"query {input_transform_output=}")
+
         sdk_input = self._client_shape_to_resource_shape_converter.query_request(input_transform_output)
 
+        print(f"query {sdk_input=}")
+
         sdk_output = self._table.query(**sdk_input)
 
         output_transform_input = self._resource_shape_to_client_shape_converter.query_response(sdk_output)

DynamoDbEncryption/runtimes/python/src/aws_database_encryption_sdk/internal/boto3_conversions.py

@@ -21,14 +21,14 @@ class BotoInterfaceShapeConverter(ABC):
     But the structure modelling is the same for both directions, and is expressed here.
     Implementations of this class should implement the abstract methods to perform the transformations.
     """
-    def key_condition_expression(self, key_condition_expression):
-        return self.expression(key_condition_expression)
+    # def key_condition_expression(self, key_condition_expression, expression_attribute_names, expression_attribute_values):
+    #     return self.expression(key_condition_expression, expression_attribute_names, expression_attribute_values)
 
-    def filter_expression(self, filter_expression):
-        return self.expression(filter_expression)
+    # def filter_expression(self, filter_expression, expression_attribute_names, expression_attribute_values):
+    #     return self.expression(filter_expression, expression_attribute_names, expression_attribute_values)
 
     @abstractmethod
-    def expression(self, condition_expression):
+    def expression(self, condition_expression, expression_attribute_names, expression_attribute_values):
         pass
 
     def key_conditions(self, key_conditions):
@@ -128,7 +128,7 @@ def scan_request(self, scan_request):
         if "ExclusiveStartKey" in scan_request:
             scan_request["ExclusiveStartKey"] = self.exclusive_start_key(scan_request["ExclusiveStartKey"])
         if "FilterExpression" in scan_request:
-            scan_request["FilterExpression"] = self.filter_expression(scan_request["FilterExpression"])
+            self._handle_expression_with_expression_attributes(scan_request, "FilterExpression")
         if "ExpressionAttributeValues" in scan_request:
             scan_request["ExpressionAttributeValues"] = self.expression_attribute_values(scan_request["ExpressionAttributeValues"])
         return scan_request
@@ -140,6 +140,18 @@ def scan_response(self, scan_response):
             scan_response["LastEvaluatedKey"] = self.last_evaluated_key(scan_response["LastEvaluatedKey"])
         return scan_response
 
+    def _handle_expression_with_expression_attributes(self, request, expression_key):
+        # Pass the resource-formatted expression attribute values to the converter
+        if "ExpressionAttributeValues" in request:
+            expression_attribute_values = request["ExpressionAttributeValues"]
+        else:
+            expression_attribute_values = {}
+        if "ExpressionAttributeNames" in request:
+            expression_attribute_names = request["ExpressionAttributeNames"]
+        else:
+            expression_attribute_names = {}
+        request[expression_key] = self.expression(request[expression_key], expression_attribute_names, expression_attribute_values)
+    
     def query_request(self, query_request):
         if "KeyConditions" in query_request:
             query_request["KeyConditions"] = self.key_conditions(query_request["KeyConditions"])
@@ -148,9 +160,9 @@ def query_request(self, query_request):
         if "ExclusiveStartKey" in query_request:
             query_request["ExclusiveStartKey"] = self.exclusive_start_key(query_request["ExclusiveStartKey"])
         if "FilterExpression" in query_request:
-            query_request["FilterExpression"] = self.filter_expression(query_request["FilterExpression"])
+            self._handle_expression_with_expression_attributes(query_request, "FilterExpression")
         if "KeyConditionExpression" in query_request:
-            query_request["KeyConditionExpression"] = self.key_condition_expression(query_request["KeyConditionExpression"])
+            self._handle_expression_with_expression_attributes(query_request, "KeyConditionExpression")
         if "ExpressionAttributeValues" in query_request:
             query_request["ExpressionAttributeValues"] = self.expression_attribute_values(query_request["ExpressionAttributeValues"])
         return query_request

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

@@ -30,6 +30,6 @@ def scan_request(self, scan_request):
         del out["TableName"]
         return out
 
-    def expression(self, condition_expression):
+    def expression(self, condition_expression, expression_attribute_names, expression_attribute_values):
         # Tables accept the same format as the client (string).
         return condition_expression

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

@@ -8,6 +8,7 @@
     ConditionBase,
     BuiltConditionExpression,
     AttributeBase,
+    Key
 )
 import re
 
@@ -60,6 +61,7 @@ def build_expression(self, condition, attribute_name_placeholders, attribute_val
             attribute_value_placeholders,
             is_key_condition=is_key_condition,
         )
+        print(f"BuiltConditionExpression {condition_expression=}")
         return BuiltConditionExpression(
             condition_expression=condition_expression,
             attribute_name_placeholders=attribute_name_placeholders,
@@ -138,37 +140,61 @@ def _build_name_placeholder(self, value, attribute_name_placeholders):
         placeholder_format = ATTR_NAME_REGEX.sub('%s', attribute_name)
         str_format_args = []
         for part in attribute_name_parts:
-            name_placeholder = self._get_name_placeholder()
-            self._name_count += 1
-            str_format_args.append(name_placeholder)
-            # Add the placeholder and value to dictionary of name placeholders.
-            attribute_name_placeholders[name_placeholder] = part
+            # If the the name is already an AttributeName, use it. Don't make a new placeholder.
+            if part in attribute_name_placeholders:
+                str_format_args.append(part)
+            else:
+                name_placeholder = self._get_name_placeholder()
+                self._name_count += 1
+                str_format_args.append(name_placeholder)
+                # Add the placeholder and value to dictionary of name placeholders.
+                attribute_name_placeholders[name_placeholder] = part
         # 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
     ):
+        print(f"{attribute_value_placeholders=}")
         # If the values are grouped, we need to add a placeholder for
         # each element inside of the actual value.
+        
+        # Also, you can define a grouped value with a colon here.
+        # If it's a colon, it's not a grouped value for the sake of this logic.
+        # Treat it as an "else" case.
         if has_grouped_values:
             placeholder_list = []
+            # If it's a pre-defined grouped attribute, don't attempt to unpack it as if it were
             for v in value:
-                value_placeholder = self._get_value_placeholder()
-                self._value_count += 1
-                placeholder_list.append(value_placeholder)
-                attribute_value_placeholders[value_placeholder] = v
+                print(f"v1 {v=}")
+                # If the value is already an AttributeValue, reuse it. Don't make a new placeholder.
+                if v in attribute_value_placeholders:
+                    print("in")
+                    placeholder_list.append(v)
+                else:
+                    print("not in")
+                    value_placeholder = self._get_value_placeholder()
+                    self._value_count += 1
+                    placeholder_list.append(value_placeholder)
+                    attribute_value_placeholders[value_placeholder] = v
             # 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) + ')'
         # Otherwise, treat the value as a single value that needs only
         # one placeholder.
         else:
-            value_placeholder = self._get_value_placeholder()
-            self._value_count += 1
-            attribute_value_placeholders[value_placeholder] = value
-            return value_placeholder
+            print(f"v2 {value=}")
+            # If the value is already an AttributeValue, reuse it. Don't make a new placeholder.
+            if value in attribute_value_placeholders:
+                print("in")
+                return value
+            else:
+                print("not in")
+                value_placeholder = self._get_value_placeholder()
+                self._value_count += 1
+                attribute_value_placeholders[value_placeholder] = value
+                return value_placeholder
 
 
 # class InternalDBESDKDynamoDBConditionExpressionBuilder:

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

@@ -1,7 +1,8 @@
 from aws_database_encryption_sdk.transform import dict_to_ddb
 from .boto3_conversions import BotoInterfaceShapeConverter
 from aws_database_encryption_sdk.internal.condition_expression_builder import InternalDBESDKDynamoDBConditionExpressionBuilder
-from boto3.dynamodb.conditions import ConditionBase, BuiltConditionExpression
+from boto3.dynamodb.conditions import BuiltConditionExpression
+from boto3.dynamodb.types import TypeSerializer
 
 class ResourceShapeToClientShapeConverter(BotoInterfaceShapeConverter):
 
@@ -34,8 +35,8 @@ def key_to_attribute_value_map(self, key_to_attribute_value):
         return dict_to_ddb(key_to_attribute_value)
 
     def attribute_value(self, attribute_value):
-        # TODO: optimize
-        return list(dict_to_ddb({"throwaway_key": attribute_value}).values())[0]
+        serializer = TypeSerializer()
+        return serializer.serialize(attribute_value)
 
     def put_item_request(self, put_item_request):
         if not self.table_name:
@@ -72,12 +73,10 @@ def scan_request(self, scan_request):
             self._unpack_built_condition_expression(super_conversion, "FilterExpression")
         return super_conversion
 
-    def expression(self, condition_expression):
+    def expression(self, condition_expression, expression_attribute_names, expression_attribute_values):
         # Expressions provided to tables can be Condition objects, which need to be converted to strings.
-        if condition_expression.__module__ == "boto3.dynamodb.conditions":
-            out = self.expression_builder.build_expression(condition_expression, {}, {})
-            print(f"{condition_expression=}")
-            print(f"{out=}")
+        if hasattr(condition_expression, "__module__") and condition_expression.__module__ == "boto3.dynamodb.conditions":
+            out = self.expression_builder.build_expression(condition_expression, expression_attribute_names, expression_attribute_values)
             return out
         # Expressions provided to tables can also already be string-like.
         # Assume the user has provided something string-like, and let Smithy-Python/DBESDK internals raise exceptions if not.

Examples/runtimes/python/DynamoDBEncryption/src/create_keystore_key_example.py

@@ -1,3 +1,5 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
 from aws_cryptographic_material_providers.keystore.models import (
     KMSConfigurationKmsKeyArn,
     CreateKeyInput,

Examples/runtimes/python/DynamoDBEncryption/src/encrypted_client.py

@@ -34,10 +34,6 @@
     DynamoDbTableEncryptionConfig,
     DynamoDbTablesEncryptionConfig,
 )
-from aws_database_encryption_sdk.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb_transforms.models import (
-    GetItemOutputTransformInput,
-    PutItemInputTransformInput
-)
 from aws_database_encryption_sdk.encryptor.client import (
     EncryptedClient
 )
@@ -142,10 +138,13 @@ def encrypted_client_put_get_example(
     put_item_request = {
         "TableName": dynamodb_table_name,
         "Item": item_to_encrypt,
+        "ReturnValuesOnConditionCheckFailure": "ALL_OLD",
     }
 
     put_item_response = encrypted_client.put_item(**put_item_request)
 
+    print(f"{put_item_response=}")
+
     # Demonstrate that PutItem succeeded
     assert put_item_response["ResponseMetadata"]["HTTPStatusCode"] == 200
 
@@ -166,5 +165,7 @@ def encrypted_client_put_get_example(
 
     # Demonstrate that GetItem succeeded
     assert get_item_response["ResponseMetadata"]["HTTPStatusCode"] == 200
-    assert get_item_response["Item"] == item_to_encrypt
-    assert get_item_response["Item"]["attribute1"] == "encrypt and sign me!"
+    print(f"{item_to_encrypt=}")
+    print(f"{get_item_response['Item']=}")
+    # assert get_item_response["Item"] == item_to_encrypt
+    assert get_item_response["Item"]["attribute1"] == {"S" : "encrypt and sign me!"}

Examples/runtimes/python/DynamoDBEncryption/src/searchable_encryption/complex_example/beacon_config.py

@@ -1,3 +1,5 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
 from aws_cryptographic_material_providers.keystore.client import KeyStore
 from aws_cryptographic_material_providers.keystore.config import KeyStoreConfig
 from aws_cryptographic_material_providers.keystore.models import (

Examples/runtimes/python/DynamoDBEncryption/src/searchable_encryption/complex_example/client/example.py

@@ -1,3 +1,5 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
 import boto3
 from ..beacon_config import setup_beacon_config
 from aws_database_encryption_sdk.encryptor.client import EncryptedClient

Examples/runtimes/python/DynamoDBEncryption/src/searchable_encryption/complex_example/client/put_requests.py

@@ -1,3 +1,5 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
 def put_all_meeting_items_to_table(ddb_table_name, ddb):
     meetings = [
         {