ruff

Author: Lucas McDonald

DynamoDbEncryption/runtimes/python/pyproject.toml

@@ -64,6 +64,9 @@ exclude = [
 line-length=120
 indent-width=4
 target-version = "py311"
+
+[tool.ruff.lint]
+# Choose linting tools
 select = [
     # pycodestyle: spacing, line length
     "E",
@@ -73,11 +76,14 @@ select = [
     "I",
     # pydocstyle: docstring style
     "D",
-    # pyupgrade: auto-upgrade syntax if possible
-    "UP",
+]
+# Ignore incompatible linting options
+ignore=[
+    "D203", # `incorrect-blank-line-before-class`; incompatible with `no-blank-line-before-class` (D211)
+    "D212", # `multi-line-summary-first-line`; incompatible with `multi-line-summary-second-line` (D213)
 ]
 
-[tool.ruff.per-file-ignores]
+[tool.ruff.lint.per-file-ignores]
 "src/aws_dbesdk_dynamodb/internal/*" = [
     # Ignore all "public"-related linting errors for internal modules
     "D100", "D101", "D102", "D103", "D104", "D105", "D106", "D107",

DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/__init__.py

@@ -1,10 +1,11 @@
 # Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
 # SPDX-License-Identifier: Apache-2.0
+"""Initialization code for AWS DBESDK for DynamoDB."""
 
 # Initialize generated Dafny, then initialize externs
 # Disable sorting imports; this order initializes code in the required order
 # (generated Dafny, then externs)
-# ruff: noqa: I001
+# ruff: noqa: I001, F401
 from .internaldafny.generated import module_
 from .internaldafny import extern
 
@@ -28,6 +29,8 @@
 
 For DBESDK DynamoDB, change the DynamoDB context to treat "Rounded" as acceptable.
 """
+# Keep these imports down here for clarity
+# ruff: noqa: E402
 from decimal import Rounded
 
 import boto3.dynamodb.types

DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/encrypted/boto3_interface.py

@@ -1,5 +1,6 @@
 # Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
 # SPDX-License-Identifier: Apache-2.0
+"""Interface for encrypted boto3 interfaces."""
 import abc
 from abc import abstractmethod
 from typing import Any
@@ -11,7 +12,8 @@ class EncryptedBotoInterface(abc.ABC):
     def _copy_sdk_response_to_dbesdk_response(
         self, sdk_response: dict[str, Any], dbesdk_response: dict[str, Any]
     ) -> dict[str, Any]:
-        """Copy any missing fields from the SDK response to the DBESDK response.
+        """
+        Copy any missing fields from the SDK response to the DBESDK response.
 
         Args:
             sdk_response: The raw SDK response
@@ -32,7 +34,8 @@ def _boto_client_attr_name(self) -> str:
         """Name of the attribute containing the underlying boto3 client."""
 
     def __getattr__(self, name: str) -> Any:
-        """Delegate unknown attributes to the underlying client.
+        """
+        Delegate unknown attributes to the underlying client.
 
         Args:
             name: The name of the attribute to get

DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/encrypted/client.py

@@ -37,7 +37,8 @@
 
 
 class EncryptedClient(EncryptedBotoInterface):
-    """Wrapper for a boto3 DynamoDB client that transparently encrypts/decrypts items.
+    """
+    Wrapper for a boto3 DynamoDB client that transparently encrypts/decrypts items.
 
     This class implements the complete boto3 DynamoDB client API, allowing it to serve as a
     drop-in replacement that transparently handles encryption and decryption of items.
@@ -74,14 +75,17 @@ def __init__(
         encryption_config: DynamoDbTablesEncryptionConfig,
         expect_standard_dictionaries: bool | None = False,
     ):
-        """Parameters
-        client (botocore.client.BaseClient): Initialized boto3 DynamoDB client
-        encryption_config (DynamoDbTablesEncryptionConfig): Initialized DynamoDbTablesEncryptionConfig
-        expect_standard_dictionaries (Optional[bool]): Does the underlying boto3 client expect items to be standard Python
-            dictionaries? This should only be set to True if you are using a client obtained
-            from a service resource or table resource (ex: `table.meta.client`).
-            If this is True, EncryptedClient will expect item-like shapes to be
-            standard Python dictionaries (default: False).
+        """
+        Create an EncryptedClient object.
+
+        Args:
+            client (botocore.client.BaseClient): Initialized boto3 DynamoDB client
+            encryption_config (DynamoDbTablesEncryptionConfig): Initialized DynamoDbTablesEncryptionConfig
+            expect_standard_dictionaries (Optional[bool]): Does the underlying boto3 client expect items
+                to be standard Python dictionaries? This should only be set to True if you are using a
+                client obtained from a service resource or table resource (ex: `table.meta.client`).
+                If this is True, EncryptedClient will expect item-like shapes to be
+                standard Python dictionaries (default: False).
 
         """
         self._client = client
@@ -92,21 +96,17 @@ def __init__(
         self._client_to_resource_shape_converter = ClientShapeToResourceShapeConverter(delete_table_name=False)
 
     def put_item(self, **kwargs) -> dict[str, Any]:
-        """Puts a single item in a table. Encrypts the item before writing to DynamoDB.
+        """
+        Put a single item to a table. Encrypts the item before writing to DynamoDB.
 
         The parameters and return value match the boto3 DynamoDB put_item API:
         https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/dynamodb/client/put_item.html
 
         Args:
-            TableName (str): Name of the table to write to
-            Item (dict): A map of attribute name/value pairs to write to the table
-
-        These are only a list of required args; see boto3 docs for complete request structure.
+            **kwargs: Keyword arguments to pass to the operation. These match the boto3 put_item API parameters.
 
         Returns:
-            dict: The response from DynamoDB.
-
-        See boto3 docs for complete response structure.
+            dict: The response from DynamoDB. This matches the boto3 put_item API response.
 
         """
         return self._client_operation_logic(
@@ -123,21 +123,17 @@ def put_item(self, **kwargs) -> dict[str, Any]:
         )
 
     def get_item(self, **kwargs) -> dict[str, Any]:
-        """Gets a single item from a table. Decrypts the item after reading from DynamoDB.
+        """
+        Get a single item from a table. Decrypts the item after reading from DynamoDB.
 
         The parameters and return value match the boto3 DynamoDB get_item API:
         https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/dynamodb/client/get_item.html
 
         Args:
-            TableName (str): Name of the table to read from
-            Key (dict): The primary key of the item to retrieve
-
-        These are only a list of required args; see boto3 docs for complete request structure.
+            **kwargs: Keyword arguments to pass to the operation. These match the boto3 get_item API parameters.
 
         Returns:
-            dict: The response from DynamoDB containing the requested item.
-
-        See boto3 docs for complete response structure.
+            dict: The response from DynamoDB. This matches the boto3 get_item API response.
 
         """
         return self._client_operation_logic(
@@ -154,20 +150,17 @@ def get_item(self, **kwargs) -> dict[str, Any]:
         )
 
     def query(self, **kwargs) -> dict[str, Any]:
-        """Queries items from a table or index. Decrypts any returned items.
+        """
+        Query items from a table or index. Decrypts any returned items.
 
         The parameters and return value match the boto3 DynamoDB query API:
         https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/dynamodb/client/query.html
 
         Args:
-            TableName (str): Name of the table to query
-
-        These are only a list of required args; see boto3 docs for complete request structure.
+            **kwargs: Keyword arguments to pass to the operation. These match the boto3 query API parameters.
 
         Returns:
-            dict: The response from DynamoDB containing the matching items.
-
-        See boto3 docs for complete response structure.
+            dict: The response from DynamoDB. This matches the boto3 query API response.
 
         """
         return self._client_operation_logic(
@@ -184,20 +177,17 @@ def query(self, **kwargs) -> dict[str, Any]:
         )
 
     def scan(self, **kwargs) -> dict[str, Any]:
-        """Scans an entire table or index. Decrypts any returned items.
+        """
+        Scan an entire table or index. Decrypts any returned items.
 
         The parameters and return value match the boto3 DynamoDB scan API:
         https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/dynamodb/client/scan.html
 
         Args:
-            TableName (str): Name of the table to scan
-
-        These are only a list of required args; see boto3 docs for complete request structure.
+            **kwargs: Keyword arguments to pass to the operation. These match the boto3 scan API parameters.
 
         Returns:
-            dict: The response from DynamoDB containing the scanned items.
-
-        See boto3 docs for complete response structure.
+            dict: The response from DynamoDB. This matches the boto3 scan API response.
 
         """
         return self._client_operation_logic(
@@ -214,21 +204,19 @@ def scan(self, **kwargs) -> dict[str, Any]:
         )
 
     def batch_write_item(self, **kwargs) -> dict[str, Any]:
-        """Puts or deletes multiple items in one or more tables.
+        """
+        Put or delete multiple items in one or more tables.
+
         For put operations, encrypts items before writing.
 
         The parameters and return value match the boto3 DynamoDB batch_write_item API:
         https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/dynamodb/client/batch_write_item.html
 
         Args:
-            RequestItems (dict): A map of table names to lists of write operations
-
-        These are only a list of required args; see boto3 docs for complete request structure.
+            **kwargs: Keyword arguments to pass to the operation. These match the boto3 batch_write_item API parameters.
 
         Returns:
-            dict: The response from DynamoDB.
-
-        See boto3 docs for complete response structure.
+            dict: The response from DynamoDB. This matches the boto3 batch_write_item API response.
 
         """
         return self._client_operation_logic(
@@ -245,20 +233,17 @@ def batch_write_item(self, **kwargs) -> dict[str, Any]:
         )
 
     def batch_get_item(self, **kwargs) -> dict[str, Any]:
-        """Gets multiple items from one or more tables. Decrypts any returned items.
+        """
+        Get multiple items from one or more tables. Decrypts any returned items.
 
         The parameters and return value match the boto3 DynamoDB batch_get_item API:
         https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/dynamodb/client/batch_get_item.html
 
         Args:
-            RequestItems (dict): A map of table names to lists of keys to retrieve
-
-        These are only a list of required args; see boto3 docs for complete request structure.
+            **kwargs: Keyword arguments to pass to the operation. These match the boto3 batch_get_item API parameters.
 
         Returns:
-            dict: The response from DynamoDB containing the requested items.
-
-        See boto3 docs for complete response structure.
+            dict: The response from DynamoDB. This matches the boto3 batch_get_item API response.
 
         """
         return self._client_operation_logic(
@@ -275,20 +260,18 @@ def batch_get_item(self, **kwargs) -> dict[str, Any]:
         )
 
     def transact_get_items(self, **kwargs) -> dict[str, Any]:
-        """Gets multiple items in a single transaction. Decrypts any returned items.
+        """
+        Get multiple items in a single transaction. Decrypts any returned items.
 
         The parameters and return value match the boto3 DynamoDB transact_get_items API:
         https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/dynamodb/client/transact_get_items.html
 
         Args:
-            TransactItems (list): List of operations to perform in the transaction
-
-        These are only a list of required args; see boto3 docs for complete request structure.
+            **kwargs: Keyword arguments to pass to the operation. These match the boto3 transact_get_items API
+                parameters.
 
         Returns:
-            dict: The response from DynamoDB containing the requested items.
-
-        See boto3 docs for complete response structure.
+            dict: The response from DynamoDB. This matches the boto3 transact_get_items API response.
 
         """
         return self._client_operation_logic(
@@ -305,21 +288,20 @@ def transact_get_items(self, **kwargs) -> dict[str, Any]:
         )
 
     def transact_write_items(self, **kwargs) -> dict[str, Any]:
-        """Performs multiple write operations in a single transaction.
+        """
+        Perform multiple write operations in a single transaction.
+        
         For put operations, encrypts items before writing.
 
         The parameters and return value match the boto3 DynamoDB transact_write_items API:
         https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/dynamodb/client/transact_write_items.html
 
         Args:
-            TransactItems (list): List of operations to perform in the transaction
-
-        These are only a list of required args; see boto3 docs for complete request structure.
+            **kwargs: Keyword arguments to pass to the operation. These match the boto3 transact_write_items API
+                parameters.
 
         Returns:
-            dict: The response from DynamoDB.
-
-        See boto3 docs for complete response structure.
+            dict: The response from DynamoDB. This matches the boto3 transact_write_items API response.
 
         """
         return self._client_operation_logic(
@@ -336,7 +318,8 @@ def transact_write_items(self, **kwargs) -> dict[str, Any]:
         )
 
     def update_item(self, **kwargs):
-        """Not implemented. Raises NotImplementedError.
+        """
+        Not implemented. Raises NotImplementedError.
 
         Args:
             **kwargs: Any arguments passed to this method
@@ -348,8 +331,11 @@ def update_item(self, **kwargs):
         raise NotImplementedError('"update_item" is not yet implemented')
 
     def get_paginator(self, operation_name: str) -> EncryptedPaginator | botocore.client.Paginator:
-        """Get a paginator from the underlying client. If the paginator requested is for
-        "scan" or "query", the paginator returned will transparently decrypt the returned items.
+        """
+        Get a paginator from the underlying client.
+        
+        If the paginator requested is for  "scan" or "query", the paginator returned will
+        transparently decrypt the returned items.
 
         https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/dynamodb.html#paginators
 
@@ -388,22 +374,27 @@ def _client_operation_logic(
         output_item_to_ddb_transform_method: callable,
         output_item_to_dict_transform_method: callable,
     ) -> dict[str, Any]:
-        """Shared logic to interface between boto3 Client operation inputs and encryption transformers.
+        """
+        Shared logic to interface between boto3 Client operation inputs and encryption transformers.
 
         This captures the shared pattern to call encryption/decryption transformer code
         and boto3 Clients across all methods in this class.
 
         Args:
             operation_input: The input to the operation
-            input_item_to_ddb_transform_method: Method to transform input items from standard dictionaries to DynamoDB JSON
-            input_item_to_dict_transform_method: Method to transform input items from DynamoDB JSON to standard dictionaries
+            input_item_to_ddb_transform_method: Method to transform input items from standard dictionaries
+                to DynamoDB JSON
+            input_item_to_dict_transform_method: Method to transform input items from DynamoDB JSON
+                to standard dictionaries
             input_transform_method: The method to transform the input for encryption
             input_transform_shape: The shape of the input transform
             output_transform_method: The method to transform the output for decryption
             output_transform_shape: The shape of the output transform
             client_method: The underlying client method to call
-            output_item_to_ddb_transform_method: Method to transform output items from standard dictionaries to DynamoDB JSON
-            output_item_to_dict_transform_method: Method to transform output items from DynamoDB JSON to standard dictionaries
+            output_item_to_ddb_transform_method: Method to transform output items from standard dictionaries
+                to DynamoDB JSON
+            output_item_to_dict_transform_method: Method to transform output items from DynamoDB JSON
+                to standard dictionaries
 
         Returns:
             dict: The transformed response from DynamoDB
@@ -446,10 +437,11 @@ def _client_operation_logic(
 
     @property
     def _boto_client_attr_name(self) -> str:
-        """Name of the attribute containing the underlying boto3 client.
+        """
+        Name of the attribute containing the underlying boto3 client.
 
         Returns:
             str: '_client'
 
         """
-        return "_client"
+        return "_client"    

DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/encrypted/item.py

@@ -30,11 +30,11 @@ def __init__(
         self,
         item_encryptor_config: DynamoDbItemEncryptorConfig,
     ):
-        """Create an ItemEncryptor.
+        """
+        Create an ItemEncryptor.
 
-        Parameters
-        ----------
-        item_encryptor_config (DynamoDbItemEncryptorConfig): Encryption configuration object.
+        Args:
+            item_encryptor_config (DynamoDbItemEncryptorConfig): Encryption configuration object.
 
         """
         self._internal_client = DynamoDbItemEncryptor(config=item_encryptor_config)
@@ -43,7 +43,8 @@ def encrypt_python_item(
         self,
         plaintext_dict_item: dict[str, Any],
     ) -> EncryptItemOutput:
-        """Encrypt a Python dictionary.
+        """
+        Encrypt a Python dictionary.
 
         This method will transform the Python dictionary into DynamoDB JSON,
             encrypt the DynamoDB JSON,
@@ -59,19 +60,17 @@ def encrypt_python_item(
         (Alternatively, you can use this library's EncryptedTable or EncryptedResource interfaces
             to transparently encrypt items without an intermediary ItemEncryptor.)
 
-        Parameters
-        ----------
-        plaintext_dict_item (dict[str, Any]): A standard Python dictionary.
+        Args:
+            plaintext_dict_item (dict[str, Any]): A standard Python dictionary.
 
-        Returns
-        -------
-        EncryptItemOutput: Structure containing the following fields:
-            - `encrypted_item` (dict[str, Any]): The encrypted Python dictionary.
-                **Note:** The item was encrypted as DynamoDB JSON, then transformed to a Python dictionary.
-            - `parsed_header` (Optional[ParsedHeader]): The encrypted DynamoDB item's header (parsed `aws_dbe_head` value).
+        Returns:
+            EncryptItemOutput: Structure containing the following fields:
+                - `encrypted_item` (dict[str, Any]): The encrypted Python dictionary.
+                    **Note:** The item was encrypted as DynamoDB JSON, then transformed to a Python dictionary.
+                - `parsed_header` (Optional[ParsedHeader]): The encrypted DynamoDB item's header (parsed
+                    `aws_dbe_head` value).
 
         Example:
-
         >>> plaintext_item = {
         ...     'some': 'data',
         ...     'more': 5
@@ -90,7 +89,8 @@ def encrypt_dynamodb_item(
         self,
         plaintext_dynamodb_item: dict[str, dict[str, Any]],
     ) -> EncryptItemOutput:
-        """Encrypt DynamoDB-formatted JSON.
+        """
+        Encrypt DynamoDB-formatted JSON.
 
         boto3 DynamoDB clients expect items formatted as DynamoDB JSON:
         https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Programming.LowLevelAPI.html
@@ -99,19 +99,16 @@ def encrypt_dynamodb_item(
         (Alternatively, you can use this library's EncryptedClient interface
             to transparently encrypt items without an intermediary ItemEncryptor.)
 
-        Parameters
-        ----------
-        plaintext_dynamodb_item (dict[str, dict[str, Any]]): The item to encrypt formatted as DynamoDB JSON.
+        Args:
+            plaintext_dynamodb_item (dict[str, dict[str, Any]]): The item to encrypt formatted as DynamoDB JSON.
 
-        Returns
-        -------
-        EncryptItemOutput: Structure containing the following fields:
-            - `encrypted_item` (dict[str, Any]): A dictionary containing the encrypted DynamoDB item
-                formatted as DynamoDB JSON.
-            - `parsed_header` (Optional[ParsedHeader]): The encrypted DynamoDB item's header (`aws_dbe_head` value).
+        Returns:
+            EncryptItemOutput: Structure containing the following fields:
+                - `encrypted_item` (dict[str, Any]): A dictionary containing the encrypted DynamoDB item
+                    formatted as DynamoDB JSON.
+                - `parsed_header` (Optional[ParsedHeader]): The encrypted DynamoDB item's header (`aws_dbe_head` value).
 
         Example:
-
         >>> plaintext_item = {
         ...     'some': {'S': 'data'},
         ...     'more': {'N': '5'}
@@ -127,24 +124,23 @@ def encrypt_item(
         self,
         encrypt_item_input: EncryptItemInput,
     ) -> EncryptItemOutput:
-        """Encrypt a DynamoDB item.
+        """
+        Encrypt a DynamoDB item.
 
         The input item should contain a dictionary formatted as DynamoDB JSON:
         https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Programming.LowLevelAPI.html
 
-        Parameters
-        ----------
-        encrypt_item_input (EncryptItemInput): Structure containing the following field:
-            - `plaintext_item` (dict[str, Any]): The item to encrypt formatted as DynamoDB JSON.
+        Args:
+            encrypt_item_input (EncryptItemInput): Structure containing the following field:
+                - `plaintext_item` (dict[str, Any]): The item to encrypt formatted as DynamoDB JSON.
 
-        Returns
-        -------
-        EncryptItemOutput: Structure containing the following fields:
-            - `encrypted_item` (dict[str, Any]): The encrypted DynamoDB item formatted as DynamoDB JSON.
-            - `parsed_header` (Optional[ParsedHeader]): The encrypted DynamoDB item's header (`aws_dbe_head` value).
+        Returns:
+            EncryptItemOutput: Structure containing the following fields:
+                - `encrypted_item` (dict[str, Any]): The encrypted DynamoDB item formatted as DynamoDB JSON.
+                - `parsed_header` (Optional[ParsedHeader]): The encrypted DynamoDB item's header
+                    (`aws_dbe_head` value).
 
         Example:
-
         >>> plaintext_item = {
         ...     'some': {'S': 'data'},
         ...     'more': {'N': '5'}
@@ -164,7 +160,8 @@ def decrypt_python_item(
         self,
         encrypted_dict_item: dict[str, Any],
     ) -> DecryptItemOutput:
-        """Decrypt a Python dictionary.
+        """
+        Decrypt a Python dictionary.
 
         This method will transform the Python dictionary into DynamoDB JSON,
             decrypt the DynamoDB JSON,
@@ -180,19 +177,17 @@ def decrypt_python_item(
         (Alternatively, you can use this library's EncryptedTable or EncryptedResource interfaces
             to transparently decrypt items without an intermediary ItemEncryptor.)
 
-        Parameters
-        ----------
-        encrypted_dict_item (dict[str, Any]): A standard Python dictionary with encrypted values.
+        Args:
+            encrypted_dict_item (dict[str, Any]): A standard Python dictionary with encrypted values.
 
-        Returns
-        -------
-        DecryptItemOutput: Structure containing the following fields:
-            - `plaintext_item` (dict[str, Any]): The decrypted Python dictionary.
-                **Note:** The item was decrypted as DynamoDB JSON, then transformed to a Python dictionary.
-            - `parsed_header` (Optional[ParsedHeader]): The encrypted DynamoDB item's header (parsed `aws_dbe_head` value).
+        Returns:
+            DecryptItemOutput: Structure containing the following fields:
+                - `plaintext_item` (dict[str, Any]): The decrypted Python dictionary.
+                    **Note:** The item was decrypted as DynamoDB JSON, then transformed to a Python dictionary.
+                - `parsed_header` (Optional[ParsedHeader]): The encrypted DynamoDB item's header
+                    (parsed `aws_dbe_head` value).
 
         Example:
-
         >>> encrypted_item = {
         ...     'some': b'ENCRYPTED_DATA',
         ...     'more': b'ENCRYPTED_DATA',
@@ -211,7 +206,8 @@ def decrypt_dynamodb_item(
         self,
         encrypted_dynamodb_item: dict[str, dict[str, Any]],
     ) -> DecryptItemOutput:
-        """Decrypt DynamoDB-formatted JSON.
+        """
+        Decrypt DynamoDB-formatted JSON.
 
         boto3 DynamoDB clients return items formatted as DynamoDB JSON:
         https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Programming.LowLevelAPI.html
@@ -220,18 +216,15 @@ def decrypt_dynamodb_item(
         (Alternatively, you can use this library's EncryptedClient interface
             to transparently decrypt items without an intermediary ItemEncryptor.)
 
-        Parameters
-        ----------
-        encrypted_ddb_item (dict[str, dict[str, Any]]): The item to decrypt formatted as DynamoDB JSON.
+        Args:
+            encrypted_dynamodb_item (dict[str, dict[str, Any]]): The item to decrypt formatted as DynamoDB JSON.
 
-        Returns
-        -------
-        DecryptItemOutput: Structure containing the following fields:
-            - `plaintext_item` (dict[str, Any]): The plaintext DynamoDB item formatted as DynamoDB JSON.
-            - `parsed_header` (Optional[ParsedHeader]): The decrypted DynamoDB item's header (`aws_dbe_head` value).
+        Returns:
+            DecryptItemOutput: Structure containing the following fields:
+                - `plaintext_item` (dict[str, Any]): The plaintext DynamoDB item formatted as DynamoDB JSON.
+                - `parsed_header` (Optional[ParsedHeader]): The decrypted DynamoDB item's header (`aws_dbe_head` value).
 
         Example:
-
         >>> encrypted_item = {
         ...     'some': {'B': b'ENCRYPTED_DATA'},
         ...     'more': {'B': b'ENCRYPTED_DATA'}
@@ -247,24 +240,22 @@ def decrypt_item(
         self,
         decrypt_item_input: DecryptItemInput,
     ) -> DecryptItemOutput:
-        """Decrypt a DynamoDB item.
+        """
+        Decrypt a DynamoDB item.
 
         The input item should contain a dictionary formatted as DynamoDB JSON:
         https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Programming.LowLevelAPI.html
 
-        Parameters
-        ----------
-        decrypt_item_input (DecryptItemInput): Structure containing the following field:
-            - `encrypted_item` (dict[str, Any]): The item to decrypt formatted as DynamoDB JSON.
+        Args:
+            decrypt_item_input (DecryptItemInput): Structure containing the following field:
+                - `encrypted_item` (dict[str, Any]): The item to decrypt formatted as DynamoDB JSON.
 
-        Returns
-        -------
-        DecryptItemOutput: Structure containing the following fields:
-            - `plaintext_item` (dict[str, Any]): The decrypted DynamoDB item formatted as DynamoDB JSON.
-            - `parsed_header` (Optional[ParsedHeader]): The decrypted DynamoDB item's header (`aws_dbe_head` value).
+        Returns:
+            DecryptItemOutput: Structure containing the following fields:
+                - `plaintext_item` (dict[str, Any]): The decrypted DynamoDB item formatted as DynamoDB JSON.
+                - `parsed_header` (Optional[ParsedHeader]): The decrypted DynamoDB item's header (`aws_dbe_head` value).
 
         Example:
-
         >>> encrypted_item = {
         ...     'some': {'B': b'ENCRYPTED_DATA'},
         ...     'more': {'B': b'ENCRYPTED_DATA'}

DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/encrypted/paginator.py

@@ -35,12 +35,18 @@ def __init__(
         encryption_config: DynamoDbTablesEncryptionConfig,
         expect_standard_dictionaries: bool | None = False,
     ):
-        """Create an EncryptedPaginator.
+        """
+        Create an EncryptedPaginator.
 
         Args:
             paginator (Paginator): A boto3 Paginator object for DynamoDB operations.
                 This can be either a "query" or "scan" Paginator.
             encryption_config (DynamoDbTablesEncryptionConfig): Encryption configuration object.
+            expect_standard_dictionaries (Optional[bool]): Does the underlying boto3 client expect items
+                to be standard Python dictionaries? This should only be set to True if you are using a
+                client obtained from a service resource or table resource (ex: `table.meta.client`).
+                If this is True, EncryptedClient will expect item-like shapes to be
+                standard Python dictionaries (default: False).
 
         """
         self._paginator = paginator
@@ -49,16 +55,15 @@ def __init__(
         self._expect_standard_dictionaries = expect_standard_dictionaries
         self._resource_to_client_shape_converter = ResourceShapeToClientShapeConverter()
         self._client_to_resource_shape_converter = ClientShapeToResourceShapeConverter(delete_table_name=False)
-        print(f"{self._paginator=}")
-        print(f"{self._paginator._model.name=}")
 
     def paginate(self, **kwargs) -> Generator[dict, None, None]:
-        """Yields a generator that paginates through responses from DynamoDB, decrypting items.
+        """
+        Yield a generator that paginates through responses from DynamoDB, decrypting items.
 
         Note:
             Calling `botocore.paginate.Paginator`'s `paginate` method for Query or Scan
             returns a `PageIterator` object, but this implementation returns a Python generator.
-            However, you can use this generator to iterate exactly as described in the official
+            However, you can use this generator to iterate exactly as described in the
             boto3 documentation:
             https://botocore.amazonaws.com/v1/documentation/api/latest/topics/paginators.html
             Any other operations on this class will defer to the underlying boto3 Paginator's implementation.
@@ -166,7 +171,8 @@ def _paginate_request(
 
     @property
     def _boto_client_attr_name(self) -> str:
-        """Name of the attribute containing the underlying boto3 client.
+        """
+        Name of the attribute containing the underlying boto3 client.
 
         Returns:
             str: '_paginator'

DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/encrypted/resource.py

@@ -1,3 +1,6 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+"""High-level helper classes to provide encrypting wrappers for boto3 DynamoDB resources."""
 from collections.abc import Callable, Generator
 from copy import deepcopy
 from typing import Any
@@ -24,15 +27,13 @@
 
 
 class EncryptedTablesCollectionManager(EncryptedBotoInterface):
-    """Tables collection manager that provides EncryptedTable objects.
+    """
+    Tables collection manager that provides EncryptedTable objects.
 
+    The API matches boto3's tables collection manager interface:
     https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/dynamodb/service-resource/tables.html
 
-    :param collection: Pre-configured boto3 DynamoDB table collection manager
-    :type collection: boto3.resources.collection.CollectionManager
-    :param CryptographicMaterialsProvider materials_provider: Cryptographic materials provider to use
-    :param AttributeActions attribute_actions: Table-level configuration of how to encrypt/sign attributes
-    :param TableInfoCache table_info_cache: Local cache from which to obtain TableInfo data
+    All operations on this class will yield EncryptedTable objects.
     """
 
     def __init__(
@@ -41,11 +42,20 @@ def __init__(
         collection: CollectionManager,
         encryption_config: DynamoDbTablesEncryptionConfig,
     ):
+        """
+        Create an EncryptedTablesCollectionManager object.
+
+        Args:
+            collection (CollectionManager): Pre-configured boto3 DynamoDB table collection manager
+            encryption_config (DynamoDbTablesEncryptionConfig): Initialized DynamoDbTablesEncryptionConfig
+
+        """
         self._collection = collection
         self._encryption_config = encryption_config
 
     def all(self) -> Generator[EncryptedTable, None, None]:
-        """Create an iterable of all EncryptedTable resources in the collection.
+        """
+        Create an iterable of all EncryptedTable resources in the collection.
 
         https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/dynamodb/service-resource/tables.html#DynamoDB.ServiceResource.all
 
@@ -56,7 +66,8 @@ def all(self) -> Generator[EncryptedTable, None, None]:
         yield from self._transform_table(self._collection.all)
 
     def filter(self, **kwargs) -> Generator[EncryptedTable, None, None]:
-        """Create an iterable of all EncryptedTable resources in the collection filtered by kwargs passed to method.
+        """
+        Create an iterable of all EncryptedTable resources in the collection filtered by kwargs passed to method.
 
         https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/dynamodb/service-resource/tables.html#filter
 
@@ -67,7 +78,8 @@ def filter(self, **kwargs) -> Generator[EncryptedTable, None, None]:
         yield from self._transform_table(self._collection.filter, **kwargs)
 
     def limit(self, **kwargs) -> Generator[EncryptedTable, None, None]:
-        """Create an iterable of all EncryptedTable resources in the collection filtered by kwargs passed to method.
+        """
+        Create an iterable of all EncryptedTable resources in the collection filtered by kwargs passed to method.
 
         https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/dynamodb/service-resource/tables.html#limit
 
@@ -78,7 +90,8 @@ def limit(self, **kwargs) -> Generator[EncryptedTable, None, None]:
         yield from self._transform_table(self._collection.limit, **kwargs)
 
     def page_size(self, **kwargs) -> Generator[EncryptedTable, None, None]:
-        """Create an iterable of all EncryptedTable resources in the collection.
+        """
+        Create an iterable of all EncryptedTable resources in the collection.
 
         This limits the number of items returned by each service call by the specified amount.
 
@@ -100,7 +113,8 @@ def _transform_table(
 
     @property
     def _boto_client_attr_name(self) -> str:
-        """Name of the attribute containing the underlying boto3 client.
+        """
+        Name of the attribute containing the underlying boto3 client.
 
         Returns:
             str: '_collection'
@@ -110,7 +124,8 @@ def _boto_client_attr_name(self) -> str:
 
 
 class EncryptedResource(EncryptedBotoInterface):
-    """Wrapper for a boto3 DynamoDB resource.
+    """
+    Wrapper for a boto3 DynamoDB resource.
 
     This class implements the complete boto3 DynamoDB resource API, allowing it to serve as a
     drop-in replacement that transparently handles encryption and decryption of items.
@@ -135,7 +150,8 @@ def __init__(
         resource: ServiceResource,
         encryption_config: DynamoDbTablesEncryptionConfig,
     ):
-        """Create an EncryptedResource object.
+        """
+        Create an EncryptedResource object.
 
         Args:
             resource (ServiceResource): Initialized boto3 DynamoDB resource
@@ -152,7 +168,8 @@ def __init__(
         )
 
     def Table(self, name):
-        """Create an EncryptedTable resource.
+        """
+        Create an EncryptedTable resource.
 
         https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/dynamodb/service-resource/Table.html
 
@@ -166,7 +183,8 @@ def Table(self, name):
         return EncryptedTable(table=self._resource.Table(name), encryption_config=self._encryption_config)
 
     def batch_get_item(self, **kwargs):
-        """Get multiple items from one or more tables. Decrypts any returned items.
+        """
+        Get multiple items from one or more tables. Decrypts any returned items.
 
         The parameters and return value match the boto3 DynamoDB batch_get_item API:
         https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/dynamodb/service-resource/batch_get_item.html
@@ -192,7 +210,8 @@ def batch_get_item(self, **kwargs):
         )
 
     def batch_write_item(self, **kwargs):
-        """Put or delete multiple items in one or more tables.
+        """
+        Put or delete multiple items in one or more tables.
 
         For put operations, encrypts items before writing.
 
@@ -273,7 +292,8 @@ def _resource_operation_logic(
 
     @property
     def _boto_client_attr_name(self) -> str:
-        """Name of the attribute containing the underlying boto3 client.
+        """
+        Name of the attribute containing the underlying boto3 client.
 
         Returns:
             str: '_resource'

DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/encrypted/table.py

@@ -30,7 +30,8 @@
 
 
 class EncryptedTable(EncryptedBotoInterface):
-    """Wrapper for a boto3 DynamoDB table that transparently encrypts/decrypts items.
+    """
+    Wrapper for a boto3 DynamoDB table that transparently encrypts/decrypts items.
 
     This class implements the complete boto3 DynamoDB table API, allowing it to serve as a
     drop-in replacement that transparently handles encryption and decryption of items.
@@ -58,12 +59,12 @@ def __init__(
         table: ServiceResource,
         encryption_config: DynamoDbTablesEncryptionConfig,
     ):
-        """Create an EncryptedTable object.
+        """
+        Create an EncryptedTable object.
 
         Args:
             table (ServiceResource): Initialized boto3 DynamoDB table
-            encryption_config (DynamoDbTablesEncryptionConfig): Initialized
-                ~aws_dbesdk_dynamodb.smithygenerated.aws_cryptography_dbencryptionsdk_dynamodb.models.DynamoDbTablesEncryptionConfig~
+            encryption_config (DynamoDbTablesEncryptionConfig): Initialized DynamoDbTablesEncryptionConfig
 
         """
         self._table = table
@@ -75,7 +76,8 @@ def __init__(
         )
 
     def put_item(self, **kwargs) -> dict[str, Any]:
-        """Put a single item to the table. Encrypts the item before writing to DynamoDB.
+        """
+        Put a single item to the table. Encrypts the item before writing to DynamoDB.
 
         The parameters and return value match the boto3 DynamoDB table put_item API:
         https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/dynamodb/table/put_item.html
@@ -101,7 +103,8 @@ def put_item(self, **kwargs) -> dict[str, Any]:
         )
 
     def get_item(self, **kwargs) -> dict[str, Any]:
-        """Get a single item from the table. Decrypts the item after reading from DynamoDB.
+        """
+        Get a single item from the table. Decrypts the item after reading from DynamoDB.
 
         The parameters and return value match the boto3 DynamoDB table get_item API:
         https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/dynamodb/table/get_item.html
@@ -127,7 +130,8 @@ def get_item(self, **kwargs) -> dict[str, Any]:
         )
 
     def query(self, **kwargs) -> dict[str, Any]:
-        """Query items from the table or index. Decrypts any returned items.
+        """
+        Query items from the table or index. Decrypts any returned items.
 
         The parameters and return value match the boto3 DynamoDB table query API:
         https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/dynamodb/table/query.html
@@ -153,7 +157,8 @@ def query(self, **kwargs) -> dict[str, Any]:
         )
 
     def scan(self, **kwargs) -> dict[str, Any]:
-        """Scan the entire table or index. Decrypts any returned items.
+        """
+        Scan the entire table or index. Decrypts any returned items.
 
         The parameters and return value match the boto3 DynamoDB table scan API:
         https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/dynamodb/table/scan.html
@@ -179,7 +184,8 @@ def scan(self, **kwargs) -> dict[str, Any]:
         )
 
     def update_item(self, **kwargs):
-        """Not implemented. Raises NotImplementedError.
+        """
+        Not implemented. Raises NotImplementedError.
 
         Args:
             **kwargs: Any arguments passed to this method
@@ -191,7 +197,8 @@ def update_item(self, **kwargs):
         raise NotImplementedError('"update_item" is not yet implemented')
 
     def batch_writer(self, overwrite_by_pkeys: list[str] | None = None) -> BatchWriter:
-        """Create a batch writer object that will transparently encrypt requests to DynamoDB.
+        """
+        Create a batch writer object that will transparently encrypt requests to DynamoDB.
 
         https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/dynamodb/table/batch_writer.html
 
@@ -226,7 +233,8 @@ def _table_operation_logic(
         output_client_to_resource_shape_transform_method: Any,
         table_method: Callable,
     ) -> dict[str, Any]:
-        """Interface between user-supplied input, encryption/decryption transformers, and boto3 Tables.
+        """
+        Interface between user-supplied input, encryption/decryption transformers, and boto3 Tables.
 
         Args:
             operation_input: User-supplied input to the operation
@@ -287,7 +295,8 @@ def _table_operation_logic(
 
     @property
     def _boto_client_attr_name(self) -> str:
-        """Name of the attribute containing the underlying boto3 client.
+        """
+        Name of the attribute containing the underlying boto3 client.
 
         Returns:
             str: '_table'

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

@@ -2,7 +2,8 @@
 
 
 class BotoInterfaceShapeConverter(ABC):
-    """Class modelling transformations between boto3 DynamoDB client and resource shapes.
+    """
+    Class modelling transformations between boto3 DynamoDB client and resource shapes.
 
     DBESDK for DynamoDB provides encrypted interfaces for boto3 DynamoDB resources (ex. Table, Resource).
     boto3 resource methods accept different input shapes than boto3 clients, and return different output shapes.

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

@@ -34,7 +34,8 @@ def reset(self):
     def build_expression(
         self, condition, attribute_name_placeholders, attribute_value_placeholders, 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

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

@@ -16,7 +16,8 @@ def __init__(self, table_name=None):
         self.expression_builder = InternalDBESDKDynamoDBConditionExpressionBuilder()
 
     def condition_handler(self, expression_key, request):
-        """Converts an object from boto3.dynamodb.conditions to a string
+        """
+        Converts an object from boto3.dynamodb.conditions to a string
         and updates ExpressionAttributeNames and ExpressionAttributeValues with any new names/values.
         The ExpressionAttributeValues are returned in resource format (Python dictionaries).
         """

DynamoDbEncryption/runtimes/python/src/aws_dbesdk_dynamodb/transform.py

@@ -1,6 +1,7 @@
 # Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
 # SPDX-License-Identifier: Apache-2.0
-"""Helper tools for translating between native and DynamoDB items.
+"""
+Helper tools for translating between native and DynamoDB items.
 
 For information on how types are serializes, see:
 https://boto3.amazonaws.com/v1/documentation/api/latest/_modules/boto3/dynamodb/types.html
@@ -13,7 +14,8 @@
 
 
 def dict_to_ddb(item: dict[str, Any]) -> dict[str, Any]:
-    """Convert a native Python dictionary to a DynamoDB-JSON item.
+    """
+    Convert a native Python dictionary to a DynamoDB-JSON item.
 
     Args:
         item (Dict[str, Any]): Native Python dictionary.
@@ -27,7 +29,8 @@ def dict_to_ddb(item: dict[str, Any]) -> dict[str, Any]:
 
 
 def list_of_dict_to_list_of_ddb(items: list[dict[str, Any]]) -> list[dict[str, Any]]:
-    """Convert a list of Python dictionaries into a list of DynamoDB-JSON formatted items.
+    """
+    Convert a list of Python dictionaries into a list of DynamoDB-JSON formatted items.
 
     Args:
         items (List[Dict[str, Any]]): List of native Python dictionaries.
@@ -40,7 +43,8 @@ def list_of_dict_to_list_of_ddb(items: list[dict[str, Any]]) -> list[dict[str, A
 
 
 def ddb_to_dict(item: dict[str, Any]) -> dict[str, Any]:
-    """Convert a DynamoDB-JSON item to a native Python dictionary.
+    """
+    Convert a DynamoDB-JSON item to a native Python dictionary.
 
     Args:
         item (Dict[str, Any]): DynamoDB-formatted item.
@@ -54,7 +58,8 @@ def ddb_to_dict(item: dict[str, Any]) -> dict[str, Any]:
 
 
 def list_of_ddb_to_list_of_dict(items: list[dict[str, Any]]) -> list[dict[str, Any]]:
-    """Convert a list of DynamoDB-JSON formatted items to a list of Python dictionaries.
+    """
+    Convert a list of DynamoDB-JSON formatted items to a list of Python dictionaries.
 
     Args:
         items (List[Dict[str, Any]]): List of DynamoDB-formatted items.