m

Author: lucasmcdonald3

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

@@ -29,28 +29,6 @@
     DynamoDbTablesEncryptionConfig,
 )
 
-from boto3.dynamodb.conditions import (
-    Key,
-    Equals,
-    NotEquals,
-    LessThan,
-    LessThanEquals,
-    GreaterThan,
-    GreaterThanEquals,
-    In,
-    Between,
-    BeginsWith,
-    And,
-    Or,
-    Contains,
-)
-from boto3.dynamodb.types import TypeSerializer
-
-from boto3.dynamodb.conditions import Key, Attr
-from boto3.dynamodb.types import TypeSerializer
-
-from boto3.dynamodb.conditions import Equals, LessThan, GreaterThan, BeginsWith, Between
-from boto3.dynamodb.types import TypeSerializer
 
 def transform_transformed_response_for_table_query_or_scan_response(sdk_output, transformed_response):
     response = transformed_response
@@ -81,20 +59,7 @@ def transform_transformed_request_for_query_or_scan_on_table(transformed_request
         for name, ddb_value in transformed_request["ExpressionAttributeValues"].items():
             dict_item = ddb_to_dict({name: ddb_value})
             transformed_request["ExpressionAttributeValues"][list(dict_item.keys())[0]] = list(dict_item.values())[0]
-    
-    # substitution_map = {}
-    # tokenized_original_string = untransformed_request["KeyConditionExpression"].split(" ")
-    # tokenized_transformed_string = untransformed_request["KeyConditionExpression"].split(" ")
-    # assert len(tokenized_original_string) == len(tokenized_transformed_string)
-    # for i in range(len(tokenized_original_string)):
-    #     original = tokenized_original_string[i]
-    #     transformed = tokenized_original_string[i]
-    #     if original != transformed:
-    #         substitution_map[original] = transformed
-    
-    
-    
-    
+
     return transformed_request
 
 
@@ -150,9 +115,6 @@ def transform_query_or_scan_input_for_internal_transformer(**kwargs):
                 kwargs["ExpressionAttributeValues"] = expression_attribute_values
     return kwargs
 
-def is_number(obj):
-    return isinstance(obj, (int, float, Decimal))
-
 def convert_conditions_to_client_expression(condition, expression_attribute_names, expression_attribute_values):
     """
     Converts a Key/Attr condition into a client-compatible DynamoDB expression.
@@ -164,279 +126,12 @@ def convert_conditions_to_client_expression(condition, expression_attribute_name
              - ExpressionAttributeNames dictionary
     """
 
-    # from boto3.dynamodb.conditions import ConditionExpressionBuilder
     from aws_database_encryption_sdk.internal.condition_expression_builder import InternalDBESDKDynamoDBConditionExpressionBuilder
 
     a = InternalDBESDKDynamoDBConditionExpressionBuilder()
     out = a.build_expression(condition, expression_attribute_names, expression_attribute_values)
-    print(f'our {out=}')
     return out
 
-    def _recurse(condition, expression_attribute_names, expression_attribute_values):
-        expression = condition.get_expression()
-        expression_format = expression["format"]
-        expression_operator = expression["operator"]
-        expression_values = expression["values"]
-        processed_expression_values = []
-
-        for elem in expression_values:
-            if isinstance(elem, Key) or isinstance(elem, Attr):
-                attribute_name = elem.name
-                # if attribute_name in expression_attribute_names:
-                #     placeholder_name = expression_attribute_names[attribute_name]
-                # else:
-                # placeholder_name = "#pln" + str(len(expression_attribute_names))
-                # expression_attribute_names[placeholder_name] = attribute_name
-                elem = attribute_name
-            elif isinstance(elem, Equals) or isinstance(elem, And) or isinstance(elem, Or) or isinstance(elem, Between) or isinstance(elem, BeginsWith) or isinstance(elem, GreaterThanEquals) or isinstance(elem, NotEquals) or isinstance(elem, Contains):
-                elem, expression_attribute_names, expression_attribute_values = _recurse(elem, expression_attribute_names, expression_attribute_values)
-            elif isinstance(elem, str) or is_number(elem):
-                # assume it's a value...
-                attribute_value = elem
-                # # if attribute_value in expression_attribute_values:
-                # #     placeholder_value = expression_attribute_values[attribute_value]
-                # # else:
-                # placeholder_value = ":plv" + str(len(expression_attribute_values))
-                # expression_attribute_values[placeholder_value] = attribute_value
-                elem = attribute_value
-            elif isinstance(elem, list):
-                s = "("
-                for list_elem in elem:
-                    s += str(list_elem)
-                s += ")"
-                elem = s
-            else:
-                print(f"unknown {elem=}")
-                print(f"unknown {elem.__dict__=}")
-                print(f"unknown {dir(elem)=}")
-                raise ValueError(f"{elem=}")
-            processed_expression_values.append(elem)
-        output = expression_format.format(*processed_expression_values, operator = expression_operator)
-        return (output, expression_attribute_names, expression_attribute_values)
-
-    condition_expression, expression_attribute_names, expression_attribute_values = _recurse(condition, expression_attribute_names, expression_attribute_values)
-    print(f"{(condition_expression, expression_attribute_names, expression_attribute_values)=}")
-    # expression_attribute_names = {v: k for k, v in swapped_expression_attribute_names.items() if }
-    # expression_attribute_values = {v: k for k, v in swapped_expression_attribute_values.items()}
-    return (condition_expression, expression_attribute_names, expression_attribute_values)
-    
-
-    def process_condition(condition):
-        nonlocal expression, expression_attribute_values, expression_attribute_names
-
-        if isinstance(condition, Equals):
-            attr_name = f"#{condition.attr_name}"
-            placeholder = f":val_{len(expression_attribute_values)}"
-            expression_attribute_names[attr_name] = condition.attr_name
-            expression_attribute_values[placeholder] = serializer.serialize(condition.values[0])
-            return f"{attr_name} = {placeholder}"
-        elif isinstance(condition, LessThan):
-            attr_name = f"#{condition.attr_name}"
-            placeholder = f":val_{len(expression_attribute_values)}"
-            expression_attribute_names[attr_name] = condition.attr_name
-            expression_attribute_values[placeholder] = serializer.serialize(condition.values[0])
-            return f"{attr_name} < {placeholder}"
-        elif isinstance(condition, GreaterThan):
-            attr_name = f"#{condition.attr_name}"
-            placeholder = f":val_{len(expression_attribute_values)}"
-            expression_attribute_names[attr_name] = condition.attr_name
-            expression_attribute_values[placeholder] = serializer.serialize(condition.values[0])
-            return f"{attr_name} > {placeholder}"
-        elif isinstance(condition, BeginsWith):
-            attr_name = f"#{condition.attr_name}"
-            placeholder = f":val_{len(expression_attribute_values)}"
-            expression_attribute_names[attr_name] = condition.attr_name
-            expression_attribute_values[placeholder] = serializer.serialize(condition.values[0])
-            return f"begins_with({attr_name}, {placeholder})"
-        elif isinstance(condition, Between):
-            attr_name = f"#{condition.attr_name}"
-            placeholder1 = f":val_{len(expression_attribute_values)}"
-            placeholder2 = f":val_{len(expression_attribute_values) + 1}"
-            expression_attribute_names[attr_name] = condition.attr_name
-            expression_attribute_values[placeholder1] = serializer.serialize(condition.values[0])
-            expression_attribute_values[placeholder2] = serializer.serialize(condition.values[1])
-            return f"{attr_name} BETWEEN {placeholder1} AND {placeholder2}"
-        else:
-            raise ValueError(f"Unsupported condition type: {type(condition).__name__}")
-
-    expression = process_condition(condition)
-
-    return expression, expression_attribute_values, expression_attribute_names
-# from boto3.dynamodb.conditions import Key, Attr
-# from boto3.dynamodb.types import TypeDeserializer
-
-# def convert_client_expression_to_conditions(expression, expression_values, expression_names=None):
-#     """
-#     Converts DynamoDB client-compatible expressions into Key or Attr conditions.
-    
-#     :param expression: A string of the DynamoDB client expression (e.g., "RecNum = :zero").
-#     :param expression_values: A dictionary of attribute values (e.g., {":zero": {"N": "0"}}).
-#     :param expression_names: A dictionary of attribute names, if placeholders are used (e.g., {"#attr": "RecNum"}).
-#     :return: A boto3.dynamodb.conditions object (Key or Attr).
-#     """
-#     # Split the expression into attribute and value
-#     tokens = expression.split()
-#     # if len(tokens) != 3:
-#     #     raise ValueError("Only simple expressions (e.g., 'AttrName = :val') are supported.")
-
-#     attr_name = tokens[0]  # The attribute name or placeholder
-#     operator = tokens[1].upper()   # The operator (e.g., '=', '<', '>', "BETWEEN")
-#     attr_value_placeholder = tokens[2]  # The value placeholder (e.g., ":zero")
-
-#     # Map operator to Key or Attr
-#     if operator == "=":
-#         return Key(attr_name).eq(attr_value_placeholder)
-#     elif operator == "<":
-#         return Key(attr_name).lt(attr_value_placeholder)
-#     elif operator == "<=":
-#         return Key(attr_name).lte(attr_value_placeholder)
-#     elif operator == ">":
-#         return Key(attr_name).gt(attr_value_placeholder)
-#     elif operator == ">=":
-#         return Key(attr_name).gte(attr_value_placeholder)
-#     elif operator == "begins_with":
-#         return Key(attr_name).begins_with(attr_value_placeholder)
-#     elif operator == "BETWEEN":
-#         raise NotImplementedError("BETWEEN is not currently supported by this function.")
-#     else:
-#         # If no Key match, assume Attr condition
-#         if operator == "!=" or operator == "<>":
-#             return Attr(attr_name).ne(attr_value_placeholder)
-#         elif operator == "contains":
-#             return Attr(attr_name).contains(attr_value_placeholder)
-#         else:
-#             raise ValueError(f"Unsupported operator: {operator}")
-
-from boto3.dynamodb.conditions import Key, Attr, And, Or, Not
-from boto3.dynamodb.types import TypeDeserializer
-
-
-def convert_client_expression_to_conditions(expression):
-    """
-    Crypto Tools internal method to convert a DynamoDB filter/key expression to boto3 Resource tokens.
-    DO NOT USE FOR ANY OTHER PURPOSE.
-    This is a basic implementation for simple expressions that will fail with complex expressions.
-    
-    To extend this to support one or a few complex expressions, consider extending the existing logic.
-    To extend this to support all expressions, consider implementing and extending the code below:
-
-    ```
-    from aws_database_encryption_sdk.internaldafny.generated.DynamoDBFilterExpr import default__ as filter_expr
-    import _dafny
-    from smithy_dafny_standard_library.internaldafny.generated import Wrappers
-
-    dafny_expr_token = filter_expr.ParseExpr(
-        _dafny.Seq(
-            expression
-        ),
-    )
-    ```
-
-    This library's generated internal Dafny code has a DynamoDB string parser.
-    This will parse a _dafny.Seq and produce Dafny tokens for the expression.
-    Implementing this will involve
-        1. Mapping Dafny tokens to boto3 Resource tokens.
-            (e.g. class Token_Between -> boto3.dynamodb.conditions.Between)
-        2. Converting Dafny token grammar to boto3 Resource token grammar.
-            (e.g.
-                Dafny: [Token_Between, Token_Open, Token_Attr, Token_And, Token_Attr, Token_Close]
-                ->
-                boto3: [Between(Attr, Attr)]
-            )
-    
-    :param expression: A string of the DynamoDB client expression (e.g., "AttrName = :val").
-    :param expression_values: A dictionary of attribute values (e.g., {":val": {"N": "0"}}).
-    :param expression_names: A dictionary of attribute names, if placeholders are used (e.g., {"#attr": "AttrName"}).
-    :return: A boto3.dynamodb.conditions object (Key, Attr, or a combination of them).
-    """
-
-    # Recursive parser for complex expressions
-    def parse_expression(expr_tokens):
-        # simple between
-        if "BETWEEN" == expr_tokens[1].upper():
-            attr_name = expr_tokens[0]
-            value1 = expr_tokens[2]
-            value2 = expr_tokens[4]
-            return Key(attr_name).between(value1, value2)
-
-        # simple in
-        elif "IN" == expr_tokens[1].upper():
-            print(f"IN {expr_tokens=}")
-            attr_name = expr_tokens[0]
-            values_in_list = expr_tokens[3:-1]
-            for i in range(len(values_in_list)):
-                if values_in_list[i][-1] == ",":
-                    values_in_list[i] = values_in_list[i][:-1]
-            return Attr(attr_name).is_in(values_in_list)
-
-        # simple contains
-        elif "CONTAINS" == expr_tokens[0].upper():
-            attr_name = expr_tokens[2]
-            if attr_name[-1] == ",":
-                attr_name = attr_name[:-1]
-            value = expr_tokens[3]
-            return Attr(attr_name).contains(value)
-        
-        # simple begins_with
-        elif "BEGINS_WITH" == expr_tokens[0].upper():
-            attr_name = expr_tokens[2]
-            if attr_name[-1] == ",":
-                attr_name = attr_name[:-1]
-            value = expr_tokens[3]
-            return Attr(attr_name).begins_with(value)
-         
-        # Base case: Single comparison or condition
-        if "AND" not in [t.upper() for t in expr_tokens] and "OR" not in [t.upper() for t in expr_tokens]:
-
-            # simple comparison
-            attr_name = expr_tokens[0]
-            operator = expr_tokens[1].upper()
-            value = expr_tokens[2]
-
-            # Map operator to Key or Attr
-            if operator == "=":
-                return Key(attr_name).eq(value)
-            elif operator == "<":
-                return Key(attr_name).lt(value)
-            elif operator == "<=":
-                return Key(attr_name).lte(value)
-            elif operator == ">":
-                return Key(attr_name).gt(value)
-            elif operator == ">=":
-                return Key(attr_name).gte(value)
-            elif operator in ("!=", "<>"):
-                return Attr(attr_name).ne(value)
-            else:
-                raise ValueError(f"Unsupported operator: {operator}")
-
-        # Recursive case: Logical AND/OR
-        stack = []
-        current_expr = []
-
-        for token in expr_tokens:
-            if token.upper() in ("AND", "OR"):
-                left = parse_expression(current_expr)
-                current_expr = []
-                stack.append((left, token))  # Save the left condition and operator
-            else:
-                current_expr.append(token)
-
-        # Handle the final condition on the right
-        right = parse_expression(current_expr)
-
-        # Combine the stack of conditions
-        while stack:
-            left, operator = stack.pop()
-            if operator.upper() == "AND":
-                right = And(left, right)
-            elif operator.upper() == "OR":
-                right = Or(left, right)
-
-        return right
-
-    # Tokenize the expression and parse it
-    tokens = expression.replace("(", " ( ").replace(")", " ) ").split()
-    return parse_expression(tokens)
 
 class EncryptedTable:
 

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

@@ -20,9 +20,9 @@ class InternalDBESDKDynamoDBConditionExpressionBuilder:
     https://github.com/boto/boto3/blob/c5c634b53be589d6e913e6dca51ad8d6480f58c7/boto3/dynamodb/conditions.py#L304
     The original class is intended to interface from boto3 Table resources to boto3 clients,
         and has logic to replace attribute names and values with placeholders.
-    This class is intended to interface from boto3 Table resources to internal DBESDK DyanmoDB operation transformers,
-        which does not expect inserted placeholders.
-    The placeholder insertion logic has been removed from this class along with its supporting logic,
+    The class defined here is intended to interface from boto3 Table resources
+        to internal DBESDK DynamoDB operation transformers, which does not expect inserted placeholders.
+    The placeholder insertion logic has been removed from this class, along with supporting logic,
         but this class maintains boto3's recursive ConditionExpression traversal logic.
     """