Implement more docstrings and bump version.

Author: pentest-gg

fastapi_users_db_dynamodb/attributes.py

@@ -8,21 +8,38 @@
 
 class GUID(Attribute[UUID_ID]):
     """
-    Custom PynamoDB attribute to store UUIDs as strings.
-    Ensures value is always a UUID object in Python.
+    Custom PynamoDB `Attribute` to store `UUID`s as strings. \
+    
+    Ensures value is always a `UUID` object in Python.
     """
 
     attr_type = STRING
     python_type = UUID_ID
 
     def serialize(self, value):
+        """Serialize a value for later storage in DynamoDB.
+
+        Args:
+            value (UUID_ID): The `UUID` to be serialized.
+
+        Returns:
+            str: The serialized `UUID` as a string.
+        """
         if value is None:
             return None
         if isinstance(value, UUID_ID):
             return str(value)
         return str(UUID_ID(value))
 
     def deserialize(self, value):
+        """Deserialize a value from DynamoDB and convert it back into a python object.
+
+        Args:
+            value (str): The serialized string representation of the `UUID`.
+
+        Returns:
+            UUID_ID: The deserialized `UUID` python object.
+        """
         if value is None:
             return None
         if not isinstance(value, UUID_ID):
@@ -38,19 +55,36 @@ class TransformingUnicodeAttribute(UnicodeAttribute):
     """
 
     def __init__(self, transform: Callable[[str], str] | None = None, **kwargs):
-        """
-        :param transform: A callable to transform the string (e.g., str.lower, str.upper)
-        :param kwargs: Other UnicodeAttribute kwargs
+        """Initialize the `Attribute` class.
+
+        Args:
+            transform (Callable[[str], str] | None, optional): A callable to transform the string (e.g., `str.lower`, `str.upper`). Defaults to None.
         """
         super().__init__(**kwargs)
         self.transform = transform
 
     def serialize(self, value):
+        """Serialize a value for later storage in DynamoDB.
+
+        Args:
+            value (str): The string to be transformed and serialized.
+
+        Returns:
+            str: The transformed and serialized object.
+        """
         if value is not None and self.transform:
             value = self.transform(value)
         return super().serialize(value)
 
     def deserialize(self, value):
+        """Deserialize a value from DynamoDB and convert it back into a python object.
+
+        Args:
+            value (str): The serialized string representation of the object.
+
+        Returns:
+            str: The deserialized python object.
+        """
         value = super().deserialize(value)
         if value is not None and self.transform:
             value = self.transform(value)

fastapi_users_db_dynamodb/config.py

@@ -1,19 +1,39 @@
 from enum import StrEnum
 from typing import Any, Literal, TypedDict
 
-__version__ = "1.0.0"
+__version__ = "1.0.1"
 
 
-# Right now, only ON-DEMAND mode is supported!
+# Right now, only ON-DEMAND/PAY_PER_REQUEST mode is supported!
 class BillingMode(StrEnum):
+    """An `Enum` class representing the billing mode of tables. \
+    
+    **NOTE**: Right now, only `PAY_PER_REQUEST` is supported!
+
+    Args:
+        StrEnum (_type_): The base enum class.
+
+    Returns:
+        _type_: The enum member, representing the billing mode.
+    """
     PAY_PER_REQUEST = "PAY_PER_REQUEST"
     # PROVISIONED = "PROVISIONED"
 
     def __str__(self) -> str:
+        """Return the billing mode directly as a string.
+
+        Returns:
+            str: The billing mode's string representation.
+        """
         return self.value
 
 
 class __ConfigMap(TypedDict):
+    """A `TypedDict`, enforcing static types on config keys.
+
+    Args:
+        TypedDict (_type_): The base type.
+    """
     DATABASE_REGION: str
     # DATABASE_BILLING_MODE: BillingMode
     DATABASE_BILLING_MODE: Literal[BillingMode.PAY_PER_REQUEST]
@@ -23,6 +43,16 @@ class __ConfigMap(TypedDict):
 
 
 def __create_config():
+    """Create a new config instance for this python process. \
+    Can be modified using this module's `get` and `set` methods.
+
+    Raises:
+        KeyError: If the key is not known or not defined.
+        TypeError: If the config expected another type for a certain key.
+
+    Returns:
+        _type_: The created `get` and `set` methods.
+    """
     __config_map: __ConfigMap = {
         "DATABASE_REGION": "eu-central-1",
         "DATABASE_BILLING_MODE": BillingMode.PAY_PER_REQUEST,
@@ -32,9 +62,28 @@ def __create_config():
     }
 
     def get(key: str, default: Any = None) -> Any:
+        """Get a value from the config dict.
+
+        Args:
+            key (str): The unique key specifying the configuration option.
+            default (Any, optional): A default value that is being returned when the key is not found. Defaults to None.
+
+        Returns:
+            Any: The configuration value.
+        """
         return __config_map.get(key, default)
 
     def set(key: str, value: Any) -> None:
+        """Set/Change a value inside of the config dict.
+
+        Args:
+            key (str): The unique key specifying the configuration option.
+            value (Any): The new value this configuration option will be changed to.
+
+        Raises:
+            KeyError: If the key is not defined or invalid.
+            TypeError: If the value's type does not match the options expected type.
+        """
         if key not in __config_map:
             raise KeyError(f"Unknown config key: {key}")
         expected_type = type(__config_map[key])  # type: ignore[literal-required]