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

clearskies_aws/backends/dynamo_db_condition_parser.py

@@ -1,10 +1,12 @@
+from __future__ import annotations
+
 import base64
 import json
 import logging
 from decimal import Decimal, DecimalException
-from typing import Any, Dict, List, Tuple
+from typing import Any
 
-from clearskies import ConditionParser
+from clearskies import Validator
 
 # Ensure AttributeValueTypeDef is imported from the correct boto3 types package
 # This is crucial for the "ideal fix".
@@ -13,7 +15,7 @@ from types_boto3_dynamodb.type_defs import AttributeValueTypeDef
 logger = logging.getLogger(__name__)
 
 
-class DynamoDBConditionParser(ConditionParser):
+class DynamoDBConditionParser(Validator):
     """
     Parses string conditions into a structured format suitable for DynamoDB PartiQL queries.
 
@@ -22,7 +24,7 @@ class DynamoDBConditionParser(ConditionParser):
     to convert Python values into the DynamoDB AttributeValue format.
     """
 
-    operator_lengths: Dict[str, int] = {
+    operator_lengths: dict[str, int] = {
         "<>": 2,
         "<=": 2,
         ">=": 2,
@@ -41,7 +43,7 @@ class DynamoDBConditionParser(ConditionParser):
         "contains": 9,
         "begins_with": 12,
     }
-    operators: List[str] = [
+    operators: list[str] = [
         # Longer operators first to help with matching
         "is not null",
         "is not missing",
@@ -61,7 +63,7 @@ class DynamoDBConditionParser(ConditionParser):
         "=",
         "in",
     ]
-    operators_for_matching: Dict[str, str] = {
+    operators_for_matching: dict[str, str] = {
         "like": " like ",
         "in": " in ",
         "is not missing": " is not missing",
@@ -73,7 +75,7 @@ class DynamoDBConditionParser(ConditionParser):
         "begins_with": " begins_with",
         "contains": " contains",
     }
-    operators_with_simple_placeholders: Dict[str, bool] = {
+    operators_with_simple_placeholders: dict[str, bool] = {
         "<>": True,
         "<=": True,
         ">=": True,
@@ -88,17 +90,17 @@ class DynamoDBConditionParser(ConditionParser):
         "is not missing",
         "is missing",
     }
-    operator_needs_remap: Dict[str, str] = {
+    operator_needs_remap: dict[str, str] = {
         "is not null": "is not missing",
         "is null": "is missing",
     }
     operators_with_special_placeholders: set[str] = {"begins_with", "contains"}
 
-    def parse_condition(self, condition: str) -> Dict[str, Any]:
+    def parse_condition(self, condition: str) -> dict[str, Any]:
         """
-        Parses a string condition into a structured dictionary.
+        Parse a string condition into a structured dictionary.
 
-        The "values" key in the returned dictionary will contain List[AttributeValueTypeDef].
+        The "values" key in the returned dictionary will contain list[AttributeValueTypeDef].
 
         Args:
             condition: The condition string to parse.
@@ -114,9 +116,7 @@ class DynamoDBConditionParser(ConditionParser):
 
         for operator in self.operators:
             try:
-                operator_for_match: str = self.operators_for_matching.get(
-                    operator, operator
-                )
+                operator_for_match: str = self.operators_for_matching.get(operator, operator)
                 index: int = lowercase_condition.index(operator_for_match)
 
                 if matching_index == -1 or index < matching_index:
@@ -134,26 +134,21 @@ class DynamoDBConditionParser(ConditionParser):
             raise ValueError(f"No supported operators found in condition {condition}")
 
         column: str = condition[:matching_index].strip()
-        value: str = condition[
-            matching_index + self.operator_lengths[matching_operator] :
-        ].strip()
+        value: str = condition[matching_index + self.operator_lengths[matching_operator] :].strip()
 
         if len(value) >= 2:
             first_char = value[0]
             last_char = value[-1]
-            if (first_char == "'" and last_char == "'") or (
-                first_char == '"' and last_char == '"'
-            ):
+            if (first_char == "'" and last_char == "'") or (first_char == '"' and last_char == '"'):
                 value = value[1:-1]
 
-        raw_values: List[str] = []
+        raw_values: list[str] = []
 
         if matching_operator == "in":
             raw_values = self._parse_condition_list(value) if value else []
         elif matching_operator not in self.operators_without_placeholders and not (
             matching_operator in self.operator_needs_remap
-            and self.operator_needs_remap[matching_operator]
-            in self.operators_without_placeholders
+            and self.operator_needs_remap[matching_operator] in self.operators_without_placeholders
         ):
             raw_values = [value]
 
@@ -165,37 +160,29 @@ class DynamoDBConditionParser(ConditionParser):
                 matching_operator = "begins_with"
                 raw_values = [value[:-1]]
             elif value.startswith("%") and not value.endswith("%"):
-                raise ValueError(
-                    "DynamoDB PartiQL does not directly support 'ends_with'"
-                )
+                raise ValueError("DynamoDB PartiQL does not directly support 'ends_with'")
             else:
                 matching_operator = "="
                 raw_values = [value]
 
-        matching_operator = self.operator_needs_remap.get(
-            matching_operator.lower(), matching_operator
-        )
+        matching_operator = self.operator_needs_remap.get(matching_operator.lower(), matching_operator)
 
         table_name: str = ""
         final_column_name: str = column
         if "." in column:
             table_prefix, column_name_part = column.split(".", 1)
             table_name = table_prefix.strip().replace('"', "").replace("`", "")
-            final_column_name = (
-                column_name_part.strip().replace('"', "").replace("`", "")
-            )
+            final_column_name = column_name_part.strip().replace('"', "").replace("`", "")
         else:
             final_column_name = column.replace('"', "").replace("`", "")
 
-        # This list will now correctly be List[AttributeValueTypeDef]
-        parameters: List[AttributeValueTypeDef] = []
+        # This list will now correctly be list[AttributeValueTypeDef]
+        parameters: list[AttributeValueTypeDef] = []
         if matching_operator.lower() not in self.operators_without_placeholders:
             for val_item in raw_values:
                 parameters.append(self.to_dynamodb_attribute_value(val_item))
 
-        column_for_parsed: str = (
-            f"{table_name}.{final_column_name}" if table_name else final_column_name
-        )
+        column_for_parsed: str = f"{table_name}.{final_column_name}" if table_name else final_column_name
 
         return {
             "table": table_name,
@@ -213,19 +200,15 @@ class DynamoDBConditionParser(ConditionParser):
         self,
         column: str,
         operator: str,
-        values: List[
-            AttributeValueTypeDef
-        ],  # Parameter 'values' is List[AttributeValueTypeDef]
+        values: list[AttributeValueTypeDef],  # Parameter 'values' is list[AttributeValueTypeDef]
         escape: bool = True,
         escape_character: str = '"',
     ) -> str:
-        """
-        Formats a SQL fragment with placeholders for a given column, operator, and parameters.
-        """
+        """Format a SQL fragment with placeholders for a given column, operator, and parameters."""
         quoted_column = column
         if escape:
-            parts: List[str] = column.split(".", 1)
-            cleaned_parts: List[str] = [part.strip('"`') for part in parts]
+            parts: list[str] = column.split(".", 1)
+            cleaned_parts: list[str] = [part.strip('"`') for part in parts]
             if len(cleaned_parts) == 2:
                 quoted_column = (
                     f"{escape_character}{cleaned_parts[0]}{escape_character}"
@@ -233,9 +216,7 @@ class DynamoDBConditionParser(ConditionParser):
                     f"{escape_character}{cleaned_parts[1]}{escape_character}"
                 )
             else:
-                quoted_column = (
-                    f"{escape_character}{cleaned_parts[0]}{escape_character}"
-                )
+                quoted_column = f"{escape_character}{cleaned_parts[0]}{escape_character}"
 
         upper_case_operator: str = operator.upper()
         lower_case_operator: str = operator.lower()
@@ -253,12 +234,8 @@ class DynamoDBConditionParser(ConditionParser):
 
         raise ValueError(f"Unsupported operator for placeholder generation: {operator}")
 
-    def to_dynamodb_attribute_value(
-        self, value: Any
-    ) -> AttributeValueTypeDef:  # Return type changed
-        """
-        Converts a Python variable into a DynamoDB-formatted attribute value dictionary.
-        """
+    def to_dynamodb_attribute_value(self, value: Any) -> AttributeValueTypeDef:  # Return type changed
+        """Convert a Python variable into a DynamoDB-formatted attribute value dictionary."""
         if isinstance(value, str):
             if value.lower() == "true":
                 return {"BOOL": True}
@@ -281,43 +258,26 @@ class DynamoDBConditionParser(ConditionParser):
         elif isinstance(value, bytes):
             return {"B": base64.b64encode(value).decode("utf-8")}
         elif isinstance(value, list):
-            # Each item will be AttributeValueTypeDef, so the list is List[AttributeValueTypeDef]
+            # Each item will be AttributeValueTypeDef, so the list is list[AttributeValueTypeDef]
             return {"L": [self.to_dynamodb_attribute_value(item) for item in value]}
         elif isinstance(value, dict):
             # Each value in the map will be AttributeValueTypeDef
-            return {
-                "M": {
-                    str(k): self.to_dynamodb_attribute_value(v)
-                    for k, v in value.items()
-                }
-            }
+            return {"M": {str(k): self.to_dynamodb_attribute_value(v) for k, v in value.items()}}
         elif isinstance(value, set):
             if not value:
-                raise ValueError(
-                    "Cannot determine DynamoDB Set type from an empty Python set."
-                )
+                raise ValueError("Cannot determine DynamoDB Set type from an empty Python set.")
             if all(isinstance(item, str) for item in value):
                 return {"SS": sorted(list(value))}
             elif all(isinstance(item, (int, float, Decimal)) for item in value):
                 return {"NS": sorted([str(item) for item in value])}
             elif all(isinstance(item, bytes) for item in value):
-                return {
-                    "BS": sorted(
-                        [base64.b64encode(item).decode("utf-8") for item in value]
-                    )
-                }
-            raise ValueError(
-                "Set contains mixed types or unsupported types for DynamoDB Sets."
-            )
+                return {"BS": sorted([base64.b64encode(item).decode("utf-8") for item in value])}
+            raise ValueError("Set contains mixed types or unsupported types for DynamoDB Sets.")
         else:
-            raise TypeError(
-                f"Unsupported Python type for DynamoDB conversion: {type(value)}"
-            )
+            raise TypeError(f"Unsupported Python type for DynamoDB conversion: {type(value)}")
 
-    def _parse_condition_list(self, list_string: str) -> List[str]:
-        """
-        Parses a string representation of a list into a list of strings.
-        """
+    def _parse_condition_list(self, list_string: str) -> list[str]:
+        """Parse a string representation of a list into a list of strings."""
         if not list_string.strip():
             return []
 
@@ -326,7 +286,7 @@ class DynamoDBConditionParser(ConditionParser):
             if not list_string.strip():
                 return []
 
-        items: List[str] = []
+        items: list[str] = []
         current_item: str = ""
         in_quotes: bool = False
         quote_char: str = ""