AbstractAWSResourceBuilder

Bases: ABC, Generic[TBuilder, TConfig]

Abstract base class for building AWS resources using the builder pattern.

This class provides a consistent interface for building various AWS resources with proper configuration validation, naming conventions, and tagging support. All concrete builders should inherit from this class and implement the required abstract methods.

Class Type Parameters:

Name	Bound or Constraints	Description	Default
-	TBuilder	The concrete builder type that inherits from this class	required
-	TConfig	The Pydantic model type used for configuration validation	required

Class Attributes

_resource_type (AWSResourceType): Must be defined by subclasses to specify the type of AWS resource being built _requires_builder_config (bool): Whether the builder requires configuration to be set before building (default: True) _requires_usage (bool): Whether the builder requires usage to be specified before building (default: False)

Source code in mare_aws_common_lib/builders/abstract_aws_resource_builder.py

class AbstractAWSResourceBuilder(ABC, Generic[TBuilder, TConfig]):
    """
    Abstract base class for building AWS resources using the builder pattern.

    This class provides a consistent interface for building various AWS resources
    with proper configuration validation, naming conventions, and tagging support.
    All concrete builders should inherit from this class and implement the required
    abstract methods.

    Type Parameters:
        - TBuilder: The concrete builder type that inherits from this class
        - TConfig: The Pydantic model type used for configuration validation

    Class Attributes:
        _resource_type (AWSResourceType): Must be defined by subclasses to specify
            the type of AWS resource being built
        _requires_builder_config (bool): Whether the builder requires configuration
            to be set before building (default: True)
        _requires_usage (bool): Whether the builder requires usage to be specified
            before building (default: False)
    """

    _resource_type: AWSResourceType  # All subclasses must define this
    _requires_builder_config: bool = True
    _requires_usage: bool = False

    def __init__(self) -> None:
        self._setup_logger()
        self.reset()

    def _setup_logger(self) -> None:
        """
        Setup a clean logger for builder operations.

        Creates a logger with the builder's class name and configures it
        with a simple message-only format. Sets logging level to ERROR
        to reduce noise during normal operations.
        """
        self.logger = logging.getLogger(TBuilder.__name__)

        if not self.logger.handlers:
            handler = logging.StreamHandler()
            formatter = logging.Formatter('%(message)s')
            handler.setFormatter(formatter)
            self.logger.addHandler(handler)
            self.logger.setLevel(logging.ERROR)
            self.logger.propagate = False

    @abstractmethod
    def reset(self) -> None:
        """
        Reset the builder to its initial state.

        Clears all configuration, helper references, tags, and other internal
        state. This method must be implemented by subclasses to handle any
        additional state they maintain.

        Note:
            This is called during initialization and can be called manually
            to reuse a builder instance for multiple resources.
        """
        self._application_helper: ApplicationHelper = None
        self._builder_config: Dict[str, Any] = {}
        self._usage: Usage = None
        self._tags: Dict[str, str] = {}
        self._config: TConfig = None

    def set_application_helper(self, app_helper: ApplicationHelper) -> TBuilder:
        """
        Set the application helper for resource naming and configuration.

        Args:
            app_helper (ApplicationHelper): Helper instance containing application
                context and configuration needed for resource creation

        Returns:
            TBuilder: Self reference for method chaining
        """
        self._application_helper = app_helper
        return self

    def set_builder_config(self, config: Dict[str, Any]) -> TBuilder:
        """
        Set the raw configuration dictionary for the builder.

        Args:
            config (Dict[str, Any]): Configuration dictionary containing
                resource-specific settings

        Returns:
            TBuilder: Self reference for method chaining
        """
        self._builder_config = config
        return self

    @abstractmethod
    def _set_config(self) -> None:
        """
        Parse and validate the builder configuration into a typed config object.

        This method should take the raw configuration from _builder_config
        and convert it into a validated Pydantic model instance stored in _config.
        Must be implemented by subclasses to handle their specific configuration
        schema.

        Raises:
            ValidationError: If the configuration is invalid according to the
                Pydantic model schema
        """
        pass

    def set_usage(self, usage: Usage) -> TBuilder:
        """
        Set the usage context for the resource being built.

        Args:
            usage (Usage): Usage enum value indicating the intended use case

        Returns:
            TBuilder: Self reference for method chaining
        """
        self._usage = usage
        return self

    def _get_snc_key_by_alias(self, scope: Construct, from_foundation: bool = False, key_id_suffix: str = None) -> kms.Key:
        """
        Retrieve an organizational KMS key for Sensitive Non Classified (SNC) data encryption.

        Constructs the standardized KMS key alias following organizational naming
        conventions and retrieves the existing key for resource encryption.
        The key alias follows the pattern:
        alias/{domain}[-foundation]-{project}-{environment}-{resource_type}-snc-key

        Args:
            scope (Construct): CDK construct scope for the key lookup
            from_foundation (bool, optional): Whether to use the foundation-provided key
                instead of a project-specific key. Defaults to False.
            key_id_suffix (str, optional): Additional suffix to append to the key ID
                for disambiguation when multiple keys share the same alias pattern.
                Defaults to None.

        Returns:
            kms.Key: KMS Key instance configured for SNC data encryption

        Note:
            The method includes debug print statements for key_alias and key_id
            which should be removed in production code.
        """
        # Build key alias
        key_parts = [f"alias/{self._application_helper.get_domain()}"]
        if from_foundation:
            key_parts.append("foundation")
        key_parts.extend([
            self._application_helper.get_project(),
            self._application_helper.get_target_env(),
            self._resource_type.value,
            "snc-key"
        ])
        key_alias = "-".join(key_parts).lower()
        key_id = key_alias
        if key_id_suffix is not None:
            key_id = f"{key_alias}/{key_id_suffix}"

        return kms.Key.from_lookup(scope, key_id.replace("-"," ").title().replace(" ", ""), alias_name=key_alias)

    def _get_cfn_logical_id(self, resource_type_suffix: str = None, git_branch: str = None, target_env: str = None) -> str:
        """
        Generate a CloudFormation logical ID for the resource.

        Args:
            resource_type_suffix (str, optional): Additional suffix to append
                to the resource type for uniqueness
            git_branch (str, optional): Git branch name to include
                in the logical ID
            target_env (str, optional): Target environment name to include
                in the logical ID

        Returns:
            str: CloudFormation-compliant logical ID for the resource
        """
        return ResourceNaming.get_cfn_logical_id(self._application_helper, self._resource_type, self._usage, 
                                                 resource_type_suffix, git_branch, target_env)

    def _get_name_for_resource(self, resource_name: str = None, git_branch: str = None, max_length: int = None) -> str:
        """
        Generate a properly formatted name for the AWS resource.

        Uses the ResourceNaming utility to create names that follow AWS naming
        conventions and organizational standards. If the name is truncated due
        to length limits, the original name is stored as a tag.

        Args:
            resource_name (str, optional): Base name for the resource
            git_branch (str, optional): CodeCommit branch name to include
            max_length (int, optional): Maximum length constraint for the name

        Returns:
            str: The formatted resource name ready for use in AWS
        """
        full_name, original_name = ResourceNaming.get_name_for_resource(self._application_helper, self._resource_type, self._usage, 
                                             resource_name, git_branch, max_length)
        if original_name is not None:
            self._tags[full_name] = original_name

        return full_name

    def _tag_resource(self, resource: Construct) -> None:
        """
        Apply accumulated tags to the specified AWS resource.

        Adds all tags that have been collected during the build process
        (such as original names before truncation) to the resource.
        Clears the internal tag collection after application.

        Args:
            resource (Construct): The AWS CDK construct to tag
        """
        if self._tags:
            for key, value in self._tags.items():
                Tags.of(resource).add(key, value)
            self._tags = {}

    @abstractmethod
    def build(self) -> Any:
        """
        Build and return the configured AWS resource.

        This is the main method that creates the actual AWS resource based on
        the accumulated configuration. Must be implemented by subclasses to
        handle their specific resource creation logic.

        Returns:
            Any: The created AWS resource (type depends on the specific builder)

        Raises:
            ValueError: If required configuration is missing or invalid
            ValidationError: If the configuration fails validation
        """
        self._control_consistency()

    def _format_validation_error(self, error: ValidationError) -> str:
        """
        Format a Pydantic validation error into a human-readable message.

        Converts ValidationError exceptions into clear, actionable error messages
        with proper formatting and context for debugging configuration issues.

        Args:
            error (ValidationError): The Pydantic validation error to format

        Returns:
            str: Formatted error message with clear field paths and descriptions
        """
        error_messages = []

        for err in error.errors():
            field_path = " -> ".join(str(loc) for loc in err['loc']) if err['loc'] else "Model"
            error_type = err['type']
            message = err['msg']
            input_value = err.get('input', 'Not provided')

            # Custom messages for common error types
            if error_type == 'missing':
                formatted_msg = f"❌ REQUIRED FIELD MISSING: '{field_path}'"
            elif error_type == 'string_type':
                formatted_msg = f"❌ INVALID TYPE for '{field_path}': Expected string, got {type(input_value).__name__} ({input_value})"
            elif error_type == 'value_error':
                # For model-level validation errors, clean up the message
                clean_message = message.replace("Value error, ", "")
                if field_path == "Model":
                    formatted_msg = f"❌ MODEL VALIDATION ERROR: {clean_message}"
                else:
                    formatted_msg = f"❌ VALIDATION ERROR for '{field_path}': {clean_message}"
            else:
                formatted_msg = f"❌ ERROR in '{field_path}': {message} (got: {input_value})"

            error_messages.append(formatted_msg)

        error_messages.append("\n")
        return "\n".join(error_messages)

    def _log_validation_error(self, error: ValidationError, model: BaseModel) -> None:
        """
        Log a formatted validation error to the logger.

        Convenience method that formats a validation error and logs it
        at ERROR level with the model name for context.

        Args:
            error (ValidationError): The validation error that occurred
            model (BaseModel): The Pydantic model that failed validation
        """
        error_msg = self._format_validation_error(error)
        logging.error(f"❌ {model.__name__} validation failed!\n{error_msg}")

    @abstractmethod
    def _control_consistency(self) -> None:
        """
        Validate that all required configuration is present before building.

        Performs consistency checks to ensure the builder is in a valid state
        for resource creation. This includes verifying required helpers,
        configurations, and usage settings based on the builder's requirements.

        Must be implemented by subclasses to add any additional consistency
        checks specific to their resource type.

        Raises:
            ValueError: If any required configuration is missing or invalid
        """
        if not self._application_helper:
            raise ValueError("Application helper must be set before building.")

        if self._requires_builder_config and not self._builder_config:
            raise ValueError("Builder configuration must be set before building.")

        if self._requires_usage:
            if not self._usage:
                raise ValueError("Usage must be set before building.")

            if not isinstance(self._usage, Usage):
                raise ValueError(f"Invalid usage type: {self._usage}. Expected one of {Usage.list()}")

Attributes

_requires_builder_config = True class-attribute instance-attribute

_requires_usage = False class-attribute instance-attribute

_resource_type instance-attribute

Functions

__init__()

Source code in mare_aws_common_lib/builders/abstract_aws_resource_builder.py

def __init__(self) -> None:
    self._setup_logger()
    self.reset()

_control_consistency() abstractmethod

Validate that all required configuration is present before building.

Performs consistency checks to ensure the builder is in a valid state for resource creation. This includes verifying required helpers, configurations, and usage settings based on the builder's requirements.

Must be implemented by subclasses to add any additional consistency checks specific to their resource type.

Raises:

Type	Description
ValueError	If any required configuration is missing or invalid

Source code in mare_aws_common_lib/builders/abstract_aws_resource_builder.py

@abstractmethod
def _control_consistency(self) -> None:
    """
    Validate that all required configuration is present before building.

    Performs consistency checks to ensure the builder is in a valid state
    for resource creation. This includes verifying required helpers,
    configurations, and usage settings based on the builder's requirements.

    Must be implemented by subclasses to add any additional consistency
    checks specific to their resource type.

    Raises:
        ValueError: If any required configuration is missing or invalid
    """
    if not self._application_helper:
        raise ValueError("Application helper must be set before building.")

    if self._requires_builder_config and not self._builder_config:
        raise ValueError("Builder configuration must be set before building.")

    if self._requires_usage:
        if not self._usage:
            raise ValueError("Usage must be set before building.")

        if not isinstance(self._usage, Usage):
            raise ValueError(f"Invalid usage type: {self._usage}. Expected one of {Usage.list()}")

_format_validation_error(error)

Format a Pydantic validation error into a human-readable message.

Converts ValidationError exceptions into clear, actionable error messages with proper formatting and context for debugging configuration issues.

Parameters:

Name	Type	Description	Default
error	ValidationError	The Pydantic validation error to format	required

Returns:

Name	Type	Description
str	str	Formatted error message with clear field paths and descriptions

Source code in mare_aws_common_lib/builders/abstract_aws_resource_builder.py

def _format_validation_error(self, error: ValidationError) -> str:
    """
    Format a Pydantic validation error into a human-readable message.

    Converts ValidationError exceptions into clear, actionable error messages
    with proper formatting and context for debugging configuration issues.

    Args:
        error (ValidationError): The Pydantic validation error to format

    Returns:
        str: Formatted error message with clear field paths and descriptions
    """
    error_messages = []

    for err in error.errors():
        field_path = " -> ".join(str(loc) for loc in err['loc']) if err['loc'] else "Model"
        error_type = err['type']
        message = err['msg']
        input_value = err.get('input', 'Not provided')

        # Custom messages for common error types
        if error_type == 'missing':
            formatted_msg = f"❌ REQUIRED FIELD MISSING: '{field_path}'"
        elif error_type == 'string_type':
            formatted_msg = f"❌ INVALID TYPE for '{field_path}': Expected string, got {type(input_value).__name__} ({input_value})"
        elif error_type == 'value_error':
            # For model-level validation errors, clean up the message
            clean_message = message.replace("Value error, ", "")
            if field_path == "Model":
                formatted_msg = f"❌ MODEL VALIDATION ERROR: {clean_message}"
            else:
                formatted_msg = f"❌ VALIDATION ERROR for '{field_path}': {clean_message}"
        else:
            formatted_msg = f"❌ ERROR in '{field_path}': {message} (got: {input_value})"

        error_messages.append(formatted_msg)

    error_messages.append("\n")
    return "\n".join(error_messages)

_get_cfn_logical_id(resource_type_suffix=None, git_branch=None, target_env=None)

Generate a CloudFormation logical ID for the resource.

Parameters:

Name	Type	Description	Default
resource_type_suffix	str	Additional suffix to append to the resource type for uniqueness	None
git_branch	str	Git branch name to include in the logical ID	None
target_env	str	Target environment name to include in the logical ID	None

Returns:

Name	Type	Description
str	str	CloudFormation-compliant logical ID for the resource

Source code in mare_aws_common_lib/builders/abstract_aws_resource_builder.py

def _get_cfn_logical_id(self, resource_type_suffix: str = None, git_branch: str = None, target_env: str = None) -> str:
    """
    Generate a CloudFormation logical ID for the resource.

    Args:
        resource_type_suffix (str, optional): Additional suffix to append
            to the resource type for uniqueness
        git_branch (str, optional): Git branch name to include
            in the logical ID
        target_env (str, optional): Target environment name to include
            in the logical ID

    Returns:
        str: CloudFormation-compliant logical ID for the resource
    """
    return ResourceNaming.get_cfn_logical_id(self._application_helper, self._resource_type, self._usage, 
                                             resource_type_suffix, git_branch, target_env)

_get_name_for_resource(resource_name=None, git_branch=None, max_length=None)

Generate a properly formatted name for the AWS resource.

Uses the ResourceNaming utility to create names that follow AWS naming conventions and organizational standards. If the name is truncated due to length limits, the original name is stored as a tag.

Parameters:

Name	Type	Description	Default
resource_name	str	Base name for the resource	None
git_branch	str	CodeCommit branch name to include	None
max_length	int	Maximum length constraint for the name	None

Returns:

Name	Type	Description
str	str	The formatted resource name ready for use in AWS

Source code in mare_aws_common_lib/builders/abstract_aws_resource_builder.py

def _get_name_for_resource(self, resource_name: str = None, git_branch: str = None, max_length: int = None) -> str:
    """
    Generate a properly formatted name for the AWS resource.

    Uses the ResourceNaming utility to create names that follow AWS naming
    conventions and organizational standards. If the name is truncated due
    to length limits, the original name is stored as a tag.

    Args:
        resource_name (str, optional): Base name for the resource
        git_branch (str, optional): CodeCommit branch name to include
        max_length (int, optional): Maximum length constraint for the name

    Returns:
        str: The formatted resource name ready for use in AWS
    """
    full_name, original_name = ResourceNaming.get_name_for_resource(self._application_helper, self._resource_type, self._usage, 
                                         resource_name, git_branch, max_length)
    if original_name is not None:
        self._tags[full_name] = original_name

    return full_name

_get_snc_key_by_alias(scope, from_foundation=False, key_id_suffix=None)

Retrieve an organizational KMS key for Sensitive Non Classified (SNC) data encryption.

Constructs the standardized KMS key alias following organizational naming conventions and retrieves the existing key for resource encryption. The key alias follows the pattern: alias/{domain}[-foundation]-{project}-{environment}-{resource_type}-snc-key

Parameters:

Name	Type	Description	Default
scope	Construct	CDK construct scope for the key lookup	required
from_foundation	bool	Whether to use the foundation-provided key instead of a project-specific key. Defaults to False.	False
key_id_suffix	str	Additional suffix to append to the key ID for disambiguation when multiple keys share the same alias pattern. Defaults to None.	None

Returns:

Type	Description
Key	kms.Key: KMS Key instance configured for SNC data encryption

Note

The method includes debug print statements for key_alias and key_id which should be removed in production code.

Source code in mare_aws_common_lib/builders/abstract_aws_resource_builder.py

def _get_snc_key_by_alias(self, scope: Construct, from_foundation: bool = False, key_id_suffix: str = None) -> kms.Key:
    """
    Retrieve an organizational KMS key for Sensitive Non Classified (SNC) data encryption.

    Constructs the standardized KMS key alias following organizational naming
    conventions and retrieves the existing key for resource encryption.
    The key alias follows the pattern:
    alias/{domain}[-foundation]-{project}-{environment}-{resource_type}-snc-key

    Args:
        scope (Construct): CDK construct scope for the key lookup
        from_foundation (bool, optional): Whether to use the foundation-provided key
            instead of a project-specific key. Defaults to False.
        key_id_suffix (str, optional): Additional suffix to append to the key ID
            for disambiguation when multiple keys share the same alias pattern.
            Defaults to None.

    Returns:
        kms.Key: KMS Key instance configured for SNC data encryption

    Note:
        The method includes debug print statements for key_alias and key_id
        which should be removed in production code.
    """
    # Build key alias
    key_parts = [f"alias/{self._application_helper.get_domain()}"]
    if from_foundation:
        key_parts.append("foundation")
    key_parts.extend([
        self._application_helper.get_project(),
        self._application_helper.get_target_env(),
        self._resource_type.value,
        "snc-key"
    ])
    key_alias = "-".join(key_parts).lower()
    key_id = key_alias
    if key_id_suffix is not None:
        key_id = f"{key_alias}/{key_id_suffix}"

    return kms.Key.from_lookup(scope, key_id.replace("-"," ").title().replace(" ", ""), alias_name=key_alias)

_log_validation_error(error, model)

Log a formatted validation error to the logger.

Convenience method that formats a validation error and logs it at ERROR level with the model name for context.

Parameters:

Name	Type	Description	Default
error	ValidationError	The validation error that occurred	required
model	BaseModel	The Pydantic model that failed validation	required

Source code in mare_aws_common_lib/builders/abstract_aws_resource_builder.py

def _log_validation_error(self, error: ValidationError, model: BaseModel) -> None:
    """
    Log a formatted validation error to the logger.

    Convenience method that formats a validation error and logs it
    at ERROR level with the model name for context.

    Args:
        error (ValidationError): The validation error that occurred
        model (BaseModel): The Pydantic model that failed validation
    """
    error_msg = self._format_validation_error(error)
    logging.error(f"❌ {model.__name__} validation failed!\n{error_msg}")

_set_config() abstractmethod

Parse and validate the builder configuration into a typed config object.

This method should take the raw configuration from _builder_config and convert it into a validated Pydantic model instance stored in _config. Must be implemented by subclasses to handle their specific configuration schema.

Raises:

Type	Description
ValidationError	If the configuration is invalid according to the Pydantic model schema

Source code in mare_aws_common_lib/builders/abstract_aws_resource_builder.py

@abstractmethod
def _set_config(self) -> None:
    """
    Parse and validate the builder configuration into a typed config object.

    This method should take the raw configuration from _builder_config
    and convert it into a validated Pydantic model instance stored in _config.
    Must be implemented by subclasses to handle their specific configuration
    schema.

    Raises:
        ValidationError: If the configuration is invalid according to the
            Pydantic model schema
    """
    pass

_setup_logger()

Setup a clean logger for builder operations.

Creates a logger with the builder's class name and configures it with a simple message-only format. Sets logging level to ERROR to reduce noise during normal operations.

Source code in mare_aws_common_lib/builders/abstract_aws_resource_builder.py

def _setup_logger(self) -> None:
    """
    Setup a clean logger for builder operations.

    Creates a logger with the builder's class name and configures it
    with a simple message-only format. Sets logging level to ERROR
    to reduce noise during normal operations.
    """
    self.logger = logging.getLogger(TBuilder.__name__)

    if not self.logger.handlers:
        handler = logging.StreamHandler()
        formatter = logging.Formatter('%(message)s')
        handler.setFormatter(formatter)
        self.logger.addHandler(handler)
        self.logger.setLevel(logging.ERROR)
        self.logger.propagate = False

_tag_resource(resource)

Apply accumulated tags to the specified AWS resource.

Adds all tags that have been collected during the build process (such as original names before truncation) to the resource. Clears the internal tag collection after application.

Parameters:

Name	Type	Description	Default
resource	Construct	The AWS CDK construct to tag	required

Source code in mare_aws_common_lib/builders/abstract_aws_resource_builder.py

def _tag_resource(self, resource: Construct) -> None:
    """
    Apply accumulated tags to the specified AWS resource.

    Adds all tags that have been collected during the build process
    (such as original names before truncation) to the resource.
    Clears the internal tag collection after application.

    Args:
        resource (Construct): The AWS CDK construct to tag
    """
    if self._tags:
        for key, value in self._tags.items():
            Tags.of(resource).add(key, value)
        self._tags = {}

build() abstractmethod

Build and return the configured AWS resource.

This is the main method that creates the actual AWS resource based on the accumulated configuration. Must be implemented by subclasses to handle their specific resource creation logic.

Returns:

Name	Type	Description
Any	Any	The created AWS resource (type depends on the specific builder)

Raises:

Type	Description
ValueError	If required configuration is missing or invalid
ValidationError	If the configuration fails validation

Source code in mare_aws_common_lib/builders/abstract_aws_resource_builder.py

@abstractmethod
def build(self) -> Any:
    """
    Build and return the configured AWS resource.

    This is the main method that creates the actual AWS resource based on
    the accumulated configuration. Must be implemented by subclasses to
    handle their specific resource creation logic.

    Returns:
        Any: The created AWS resource (type depends on the specific builder)

    Raises:
        ValueError: If required configuration is missing or invalid
        ValidationError: If the configuration fails validation
    """
    self._control_consistency()

reset() abstractmethod

Reset the builder to its initial state.

Clears all configuration, helper references, tags, and other internal state. This method must be implemented by subclasses to handle any additional state they maintain.

Note

This is called during initialization and can be called manually to reuse a builder instance for multiple resources.

Source code in mare_aws_common_lib/builders/abstract_aws_resource_builder.py

@abstractmethod
def reset(self) -> None:
    """
    Reset the builder to its initial state.

    Clears all configuration, helper references, tags, and other internal
    state. This method must be implemented by subclasses to handle any
    additional state they maintain.

    Note:
        This is called during initialization and can be called manually
        to reuse a builder instance for multiple resources.
    """
    self._application_helper: ApplicationHelper = None
    self._builder_config: Dict[str, Any] = {}
    self._usage: Usage = None
    self._tags: Dict[str, str] = {}
    self._config: TConfig = None

set_application_helper(app_helper)

Set the application helper for resource naming and configuration.

Parameters:

Name	Type	Description	Default
app_helper	ApplicationHelper	Helper instance containing application context and configuration needed for resource creation	required

Returns:

Name	Type	Description
TBuilder	TBuilder	Self reference for method chaining

Source code in mare_aws_common_lib/builders/abstract_aws_resource_builder.py

def set_application_helper(self, app_helper: ApplicationHelper) -> TBuilder:
    """
    Set the application helper for resource naming and configuration.

    Args:
        app_helper (ApplicationHelper): Helper instance containing application
            context and configuration needed for resource creation

    Returns:
        TBuilder: Self reference for method chaining
    """
    self._application_helper = app_helper
    return self

set_builder_config(config)

Set the raw configuration dictionary for the builder.

Parameters:

Name	Type	Description	Default
config	Dict[str, Any]	Configuration dictionary containing resource-specific settings	required

Returns:

Name	Type	Description
TBuilder	TBuilder	Self reference for method chaining

Source code in mare_aws_common_lib/builders/abstract_aws_resource_builder.py

def set_builder_config(self, config: Dict[str, Any]) -> TBuilder:
    """
    Set the raw configuration dictionary for the builder.

    Args:
        config (Dict[str, Any]): Configuration dictionary containing
            resource-specific settings

    Returns:
        TBuilder: Self reference for method chaining
    """
    self._builder_config = config
    return self

set_usage(usage)

Set the usage context for the resource being built.

Parameters:

Name	Type	Description	Default
usage	Usage	Usage enum value indicating the intended use case	required

Returns:

Name	Type	Description
TBuilder	TBuilder	Self reference for method chaining

Source code in mare_aws_common_lib/builders/abstract_aws_resource_builder.py

def set_usage(self, usage: Usage) -> TBuilder:
    """
    Set the usage context for the resource being built.

    Args:
        usage (Usage): Usage enum value indicating the intended use case

    Returns:
        TBuilder: Self reference for method chaining
    """
    self._usage = usage
    return self