boto3-assist 0.40.0__py3-none-any.whl → 0.41.0__py3-none-any.whl

boto3_assist/dynamodb/dynamodb_index.py

@@ -38,7 +38,7 @@ class DynamoDBIndexes:
             raise ValueError(
                 f"The index {index.name} is already defined in your model somewhere. "
                 "This error is generated to protect you from unforeseen issues. "
-                "If you models are inheriting from other models, you may have the primary defined twice."
+                "If your models are inheriting from other models, you may have the primary defined twice."
             )
 
         self.__indexes[DynamoDBIndexes.PRIMARY_INDEX] = index
@@ -152,19 +152,19 @@ class DynamoDBIndex:
     def to_dict(self, include_sort_key: bool = True) -> dict[str, str]:
         """
         Return a dictionary representation of this index's keys for debugging.
-        
+
         This is particularly useful for:
         - Debugging key generation logic
         - Logging DynamoDB operations
         - Verifying composite key structure
         - Testing key values
-        
+
         Args:
             include_sort_key: Whether to include the sort key (default: True)
-            
+
         Returns:
             Dictionary with partition key and optionally sort key.
-            
+
         Example:
             >>> index = DynamoDBIndex()
             >>> index.partition_key.attribute_name = "pk"
@@ -173,21 +173,21 @@ class DynamoDBIndex:
             >>> index.sort_key.value = lambda: "user#123"
             >>> index.to_dict()
             {'pk': 'user#123', 'sk': 'user#123'}
-            
+
             >>> # Partition key only
             >>> index.to_dict(include_sort_key=False)
             {'pk': 'user#123'}
-            
+
             >>> # Useful for debugging
             >>> print(f"Querying with key: {index.to_dict()}")
             Querying with key: {'pk': 'user#123', 'sk': 'user#123'}
         """
         result = {}
-        
+
         # Always include partition key
         if self.__pk:
             result[self.partition_key.attribute_name] = self.partition_key.value
-        
+
         # Optionally include sort key
         if include_sort_key and self.__sk and self.sort_key.attribute_name:
             try:
@@ -195,7 +195,7 @@ class DynamoDBIndex:
             except ValueError:
                 # Sort key value not set, skip it
                 pass
-                
+
         return result
 
     def debug_info(
@@ -208,22 +208,22 @@ class DynamoDBIndex:
     ) -> dict[str, Any]:
         """
         Return detailed debugging information about this index and how it would be queried.
-        
+
         This is useful for understanding:
         - What keys are defined
         - What condition would be used in a query
         - What the actual key values are
         - What index name would be used
-        
+
         Args:
             include_sort_key: Whether to include the sort key (default: True)
             condition: The condition type being used (default: "begins_with")
             low_value: Low value for "between" condition
             high_value: High value for "between" condition
-            
+
         Returns:
             Dictionary with debugging information including keys, condition, and index details.
-            
+
         Example:
             >>> index = product.indexes.get("gsi1")
             >>> debug = index.debug_info(condition="begins_with")
@@ -242,54 +242,60 @@ class DynamoDBIndex:
                 'keys_dict': {'gsi1_pk': 'category#electronics', 'gsi1_sk': 'product#prod_123'},
                 'query_type': 'GSI' or 'Primary'
             }
-            
+
             >>> # Check condition type
             >>> if debug['sort_key']['condition'] == 'begins_with':
             ...     print("This query uses begins_with")
         """
         result = {
-            'index_name': self.name,
-            'query_type': 'Primary' if self.name == DynamoDBIndexes.PRIMARY_INDEX else 'GSI/LSI'
+            "index_name": self.name,
+            "query_type": (
+                "Primary" if self.name == DynamoDBIndexes.PRIMARY_INDEX else "GSI/LSI"
+            ),
         }
-        
+
         # Partition key info
         if self.__pk:
-            result['partition_key'] = {
-                'attribute': self.partition_key.attribute_name,
-                'value': self.partition_key.value
+            result["partition_key"] = {
+                "attribute": self.partition_key.attribute_name,
+                "value": self.partition_key.value,
             }
-        
+
         # Sort key info with condition
         if include_sort_key and self.__sk and self.sort_key.attribute_name:
             try:
                 sk_info = {
-                    'attribute': self.sort_key.attribute_name,
-                    'value': self.sort_key.value,
-                    'condition': condition
+                    "attribute": self.sort_key.attribute_name,
+                    "value": self.sort_key.value,
+                    "condition": condition,
                 }
-                
+
                 # Add range info for between condition
-                if condition == "between" and low_value is not None and high_value is not None:
-                    sk_info['low_value'] = low_value
-                    sk_info['high_value'] = high_value
-                    sk_info['full_range'] = {
-                        'low': f"{self.sort_key.value}{low_value}",
-                        'high': f"{self.sort_key.value}{high_value}"
+                if (
+                    condition == "between"
+                    and low_value is not None
+                    and high_value is not None
+                ):
+                    sk_info["low_value"] = low_value
+                    sk_info["high_value"] = high_value
+                    sk_info["full_range"] = {
+                        "low": f"{self.sort_key.value}{low_value}",
+                        "high": f"{self.sort_key.value}{high_value}",
                     }
-                
-                result['sort_key'] = sk_info
+
+                result["sort_key"] = sk_info
             except ValueError:
                 # Sort key value not set
-                result['sort_key'] = {
-                    'attribute': self.sort_key.attribute_name,
-                    'value': None,
-                    'condition': condition,
-                    'note': 'Sort key value not set'
+                result["sort_key"] = {
+                    "attribute": self.sort_key.attribute_name,
+                    "value": None,
+                    "condition": condition,
+                    "note": "Sort key value not set",
                 }
-        
+
         # Include the keys dictionary for convenience
-        result['keys_dict'] = self.to_dict(include_sort_key=include_sort_key)
-        
+        result["keys_dict"] = self.to_dict(include_sort_key=include_sort_key)
+
         return result
 
     def key(
@@ -393,25 +399,24 @@ class DynamoDBIndex:
 
     @staticmethod
     def extract_key_values(
-        key_expression: And | Equals,
-        index: Optional[str | DynamoDBIndex] = None
+        key_expression: And | Equals, index: Optional[str | DynamoDBIndex] = None
     ) -> dict[str, Any]:
         """
         Extract key values and condition information from a boto3 Key condition expression.
-        
+
         This is useful for debugging queries at runtime to see exactly what values
         are being used in the KeyConditionExpression.
-        
+
         Args:
             key_expression: The Key condition expression (from key() or _build_query_key())
             index: Optional index name (str) or DynamoDBIndex object to include in results
-            
+
         Returns:
             Dictionary containing:
                 - index_name: str (if index parameter provided)
                 - partition_key: {'attribute': str, 'value': str}
                 - sort_key: {'attribute': str, 'value': str, 'operator': str, 'format': str} (if present)
-                
+
         Example:
             >>> index = model.indexes.get("gsi1")
             >>> key_expr = index.key(query_key=True, condition="begins_with")
@@ -430,10 +435,10 @@ class DynamoDBIndex:
                     'format': '{operator}({0}, {1})'
                 }
             }
-            
+
             >>> # Or pass just the index name
             >>> debug = DynamoDBIndex.extract_key_values(key_expr, "gsi1")
-            
+
             >>> # Quick access to values
             >>> pk_value = debug['partition_key']['value']
             >>> sk_value = debug['sort_key']['value']
@@ -441,67 +446,82 @@ class DynamoDBIndex:
             >>> index_name = debug.get('index_name')
         """
         result = {}
-        
+
         # Include index name if provided
         if index is not None:
             if isinstance(index, str):
-                result['index_name'] = index
+                result["index_name"] = index
             elif isinstance(index, DynamoDBIndex):
-                result['index_name'] = index.name
-        
+                result["index_name"] = index.name
+
         try:
             # The key_expression._values is a list of conditions
             # [0] is the partition key (Equals condition)
             # [1] is the sort key (ComparisonCondition) if present
-            
-            if hasattr(key_expression, '_values') and len(key_expression._values) > 0:
+
+            if hasattr(key_expression, "_values") and len(key_expression._values) > 0:
                 # Extract partition key
                 pk_condition = key_expression._values[0]
-                if hasattr(pk_condition, '_values') and len(pk_condition._values) >= 2:
+                if hasattr(pk_condition, "_values") and len(pk_condition._values) >= 2:
                     pk_attr = pk_condition._values[0]
-                    result['partition_key'] = {
-                        'attribute': pk_attr.name if hasattr(pk_attr, 'name') else str(pk_attr),
-                        'value': pk_condition._values[1]
+                    result["partition_key"] = {
+                        "attribute": (
+                            pk_attr.name if hasattr(pk_attr, "name") else str(pk_attr)
+                        ),
+                        "value": pk_condition._values[1],
                     }
-                
+
                 # Extract sort key if present
                 if len(key_expression._values) > 1:
                     sk_condition = key_expression._values[1]
-                    if hasattr(sk_condition, '_values'):
-                        sk_attr = sk_condition._values[0] if len(sk_condition._values) > 0 else None
+                    if hasattr(sk_condition, "_values"):
+                        sk_attr = (
+                            sk_condition._values[0]
+                            if len(sk_condition._values) > 0
+                            else None
+                        )
                         sk_info = {
-                            'attribute': sk_attr.name if (sk_attr and hasattr(sk_attr, 'name')) else str(sk_attr),
+                            "attribute": (
+                                sk_attr.name
+                                if (sk_attr and hasattr(sk_attr, "name"))
+                                else str(sk_attr)
+                            ),
                         }
-                        
+
                         # Get value(s)
                         if len(sk_condition._values) > 1:
-                            sk_info['value'] = sk_condition._values[1]
-                        
+                            sk_info["value"] = sk_condition._values[1]
+
                         # For 'between' condition, there are two values
                         if len(sk_condition._values) > 2:
-                            sk_info['value_low'] = sk_condition._values[1]
-                            sk_info['value_high'] = sk_condition._values[2]
-                            del sk_info['value']  # Remove single value key
-                        
+                            sk_info["value_low"] = sk_condition._values[1]
+                            sk_info["value_high"] = sk_condition._values[2]
+                            del sk_info["value"]  # Remove single value key
+
                         # Get operator and format
-                        if hasattr(sk_condition, 'expression_operator'):
-                            sk_info['operator'] = sk_condition.expression_operator
-                        if hasattr(sk_condition, 'expression_format'):
-                            sk_info['format'] = sk_condition.expression_format
-                        
-                        result['sort_key'] = sk_info
-            
+                        if hasattr(sk_condition, "expression_operator"):
+                            sk_info["operator"] = sk_condition.expression_operator
+                        if hasattr(sk_condition, "expression_format"):
+                            sk_info["format"] = sk_condition.expression_format
+
+                        result["sort_key"] = sk_info
+
             # If no _values found, handle single Equals condition (no sort key)
             elif isinstance(key_expression, Equals):
-                if hasattr(key_expression, '_values') and len(key_expression._values) >= 2:
+                if (
+                    hasattr(key_expression, "_values")
+                    and len(key_expression._values) >= 2
+                ):
                     pk_attr = key_expression._values[0]
-                    result['partition_key'] = {
-                        'attribute': pk_attr.name if hasattr(pk_attr, 'name') else str(pk_attr),
-                        'value': key_expression._values[1]
+                    result["partition_key"] = {
+                        "attribute": (
+                            pk_attr.name if hasattr(pk_attr, "name") else str(pk_attr)
+                        ),
+                        "value": key_expression._values[1],
                     }
-                    
+
         except (AttributeError, IndexError) as e:
-            result['error'] = f"Unable to extract key values: {str(e)}"
-            result['note'] = "The Key expression structure may have changed"
-        
+            result["error"] = f"Unable to extract key values: {str(e)}"
+            result["note"] = "The Key expression structure may have changed"
+
         return result

boto3_assist/version.py

@@ -1 +1 @@
-__version__ = "0.40.0"
+__version__ = "0.41.0"

{boto3_assist-0.40.0.dist-info → boto3_assist-0.41.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boto3_assist
-Version: 0.40.0
+Version: 0.41.0
 Summary: Additional boto3 wrappers to make your life a little easier
 Author-email: Eric Wilson <boto3-assist@geekcafe.com>
 License-File: LICENSE-EXPLAINED.txt

{boto3_assist-0.40.0.dist-info → boto3_assist-0.41.0.dist-info}/RECORD

@@ -7,7 +7,7 @@ boto3_assist/connection_tracker.py,sha256=UgfR9RlvXf3A4ssMr3gDMpw89ka8mSRvJn4M34
 boto3_assist/http_status_codes.py,sha256=G0zRSWenwavYKETvDF9tNVUXQz3Ae2gXdBETYbjvJe8,3284
 boto3_assist/role_assumption_mixin.py,sha256=PMUU5yC2FUBjFD1UokVkRY3CPB5zTw85AhIB5BMtbc8,1031
 boto3_assist/session_setup_mixin.py,sha256=X-JQKyyaWNA8Z8kKgf2V2I5vsiLAH8udLTX_xepnsdQ,3140
-boto3_assist/version.py,sha256=_ExaG55L38qKQZWAUr2OC6wbl37pJ9GTCjtqQbCdwB0,23
+boto3_assist/version.py,sha256=WqzeTKVe9Q7QeiOa2KhoieBiGxzHK-Gb2TvnyeIJEKk,23
 boto3_assist/aws_lambda/event_info.py,sha256=OkZ4WzuGaHEu_T8sB188KBgShAJhZpWASALKRGBOhMg,14648
 boto3_assist/aws_lambda/mock_context.py,sha256=LPjHP-3YSoY6iPl1kPqJDwSVf1zLNTcukUunDtYcbK0,116
 boto3_assist/cloudwatch/cloudwatch_connection.py,sha256=mnGWaLSQpHh5EeY7Ek_2o9JKHJxOELIYtQVMX1IaHn4,2480
@@ -25,7 +25,7 @@ boto3_assist/dynamodb/dynamodb.py,sha256=HY9i_PIxUW5-Mz6rQrmKfyd1Mwl-VwogH3w-Ckt
 boto3_assist/dynamodb/dynamodb_connection.py,sha256=1fA8iC6lq5F4bItJZZwL22fNgVBl7Sw6rV01PXVQ8Cc,3703
 boto3_assist/dynamodb/dynamodb_helpers.py,sha256=BYJEuXaQVCPbDfbtPswWA_OvV_yC3fVoTtKvIoZeIBc,12092
 boto3_assist/dynamodb/dynamodb_importer.py,sha256=nCKsyRQeMqDSf0Q5mQ_X_oVIg4PRnu0hcUzZnBli610,3471
-boto3_assist/dynamodb/dynamodb_index.py,sha256=2AKxHo8HrRbaxL0ePj7S6ek36_sy5cHkDp5I9wIp8Kw,19797
+boto3_assist/dynamodb/dynamodb_index.py,sha256=EySBmzNIGqUjPZFUWFswXamPNPkfGisy-7ynu0Y8aJk,19861
 boto3_assist/dynamodb/dynamodb_iservice.py,sha256=O9Aj0PFEvcuk2vhARifWTFnUwcQW5EXzwZS478Hm-N0,796
 boto3_assist/dynamodb/dynamodb_key.py,sha256=adUnMN6HARTY3Co3hPiodXaW82Q_CCqvT-LjZ8-rP14,4130
 boto3_assist/dynamodb/dynamodb_model_base.py,sha256=gCUG0UKXV9AUcPBlbxJ3Xb8wOS8awrGG7DZpZjgIS58,21291
@@ -66,8 +66,8 @@ boto3_assist/utilities/logging_utility.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5N
 boto3_assist/utilities/numbers_utility.py,sha256=wzv9d0uXT_2_ZHHio7LBzibwxPqhGpvbq9HinrVn_4A,10160
 boto3_assist/utilities/serialization_utility.py,sha256=m5wRZNeWW9VltQPVNziR27OGKO3MDJm6mFmcDHwN-n4,24479
 boto3_assist/utilities/string_utility.py,sha256=XxUIz19L2LFFTRDAAmdPa8Qhn40u9yO7g4nULFuvg0M,11033
-boto3_assist-0.40.0.dist-info/METADATA,sha256=5_jINdvUKPSIhxoDPYm0mCPGVigMUc5ecFbS1iICqWc,2879
-boto3_assist-0.40.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-boto3_assist-0.40.0.dist-info/licenses/LICENSE-EXPLAINED.txt,sha256=WFREvTpfTjPjDHpOLADxJpCKpIla3Ht87RUUGii4ODU,606
-boto3_assist-0.40.0.dist-info/licenses/LICENSE.txt,sha256=PXDhFWS5L5aOTkVhNvoitHKbAkgxqMI2uUPQyrnXGiI,1105
-boto3_assist-0.40.0.dist-info/RECORD,,
+boto3_assist-0.41.0.dist-info/METADATA,sha256=Hk7GCF0InL5y1uV5Lf9lzxPScwtEDMurJxE3ACrqmXY,2879
+boto3_assist-0.41.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+boto3_assist-0.41.0.dist-info/licenses/LICENSE-EXPLAINED.txt,sha256=WFREvTpfTjPjDHpOLADxJpCKpIla3Ht87RUUGii4ODU,606
+boto3_assist-0.41.0.dist-info/licenses/LICENSE.txt,sha256=PXDhFWS5L5aOTkVhNvoitHKbAkgxqMI2uUPQyrnXGiI,1105
+boto3_assist-0.41.0.dist-info/RECORD,,