tessl/pypi-troposphere

AWS CloudFormation creation library that facilitates building infrastructure templates programmatically in Python

Overview

Eval results

Files

Template Management

Name: tessl/pypi-troposphere
Author: tessl

Core functionality for creating and managing CloudFormation templates, including adding resources, parameters, outputs, mappings, conditions, and converting templates to JSON/YAML formats.

Capabilities

Template Creation and Configuration

Create CloudFormation templates with metadata, descriptions, and version settings.

class Template:
    def __init__(self, Description: Optional[str] = None, Metadata: Optional[Dict[str, Any]] = None):
        """
        Create a new CloudFormation template.
        
        Args:
            Description (str, optional): Template description
            Metadata (dict, optional): Template metadata
        """

    def set_description(self, description: str) -> None:
        """Set template description."""

    def set_metadata(self, metadata: Dict[str, Any]) -> None:
        """Set template metadata."""

    def set_version(self, version: Optional[str] = None) -> None:
        """
        Set CloudFormation template format version.
        
        Args:
            version (str, optional): Template version, defaults to "2010-09-09"
        """

    def set_transform(self, transform: Union[List[object], str]) -> None:
        """
        Set template transforms (e.g., AWS::Serverless-2016-10-31).
        
        Args:
            transform: Transform name or list of transforms
        """
        
    def set_globals(self, globals: Globals) -> None:
        """
        Set SAM template globals (requires Serverless transform).
        
        Args:
            globals: Globals configuration for SAM templates
        """

Resource Management

Add and manage CloudFormation resources within templates with automatic validation and duplicate detection.

def add_resource(self, resource) -> resource:
    """
    Add a resource to the template.
    
    Args:
        resource: AWSObject instance or list of AWSObject instances
        
    Returns:
        The added resource(s)
        
    Raises:
        ValueError: If maximum resources (500) exceeded or duplicate key detected
    """

def get_or_add_parameter(self, parameter: Parameter) -> Parameter:
    """
    Get existing parameter or add new one.
    
    Args:
        parameter: Parameter instance
        
    Returns:
        Parameter: Existing or newly added parameter
    """

Parameter Management

Manage template parameters with validation and limits enforcement.

def add_parameter(self, parameter) -> parameter:
    """
    Add parameter(s) to template.
    
    Args:
        parameter: Parameter instance or list of Parameter instances
        
    Returns:
        The added parameter(s)
        
    Raises:
        ValueError: If maximum parameters (200) exceeded or duplicate key detected
    """

def set_parameter_label(self, parameter: Union[Parameter, str], label: str) -> None:
    """
    Set parameter label for CloudFormation UI.
    
    Args:
        parameter: Parameter instance or parameter name
        label: Display label for parameter
    """

def add_parameter_to_group(self, parameter: Union[Parameter, str], group_name: str) -> str:
    """
    Add parameter to a parameter group.
    
    Args:
        parameter: Parameter instance or parameter name
        group_name: Name of parameter group (created if doesn't exist)
        
    Returns:
        str: Group name
    """

Output Management

Manage template outputs with export capabilities for cross-stack references.

def add_output(self, output) -> output:
    """
    Add output(s) to template.
    
    Args:
        output: Output instance or list of Output instances
        
    Returns:
        The added output(s)
        
    Raises:
        ValueError: If maximum outputs (200) exceeded or duplicate key detected
    """

Mappings and Conditions

Add mappings for static lookups and conditions for conditional resource creation.

def add_mapping(self, name: str, mapping: Dict[str, Any]) -> None:
    """
    Add mapping to template.
    
    Args:
        name: Mapping name
        mapping: Mapping dictionary
        
    Raises:
        ValueError: If maximum mappings (200) exceeded
    """

def add_condition(self, name: str, condition: AWSHelperFn) -> str:
    """
    Add condition to template.
    
    Args:
        name: Condition name
        condition: AWSHelperFn representing the condition logic
        
    Returns:
        str: Condition name
    """

Rules Management

Add template rules for parameter validation and constraints.

def add_rule(self, name: str, rule: object) -> None:
    """
    Add rule to template for parameter constraints.
    
    Args:
        name: Rule name
        rule: Rule dictionary with 'Assertions' and optional 'RuleCondition'
        
    Raises:
        ValueError: If duplicate rule name detected
    """

Template Conversion

Convert templates to various output formats.

def to_dict(self) -> Dict[str, Any]:
    """
    Convert template to dictionary format.
    
    Returns:
        dict: Template as dictionary
    """

def to_json(self, indent: int = 1, sort_keys: bool = True, 
           separators: Tuple[str, str] = (",", ": ")) -> str:
    """
    Convert template to JSON string.
    
    Args:
        indent: JSON indentation level
        sort_keys: Whether to sort keys alphabetically
        separators: JSON separators tuple
        
    Returns:
        str: Template as JSON string
    """

def to_yaml(self, clean_up: bool = False, long_form: bool = False, 
           sort_keys: bool = True) -> str:
    """
    Convert template to YAML string.
    
    Args:
        clean_up: Whether to clean up CloudFormation-specific syntax
        long_form: Whether to use long-form YAML syntax
        sort_keys: Whether to sort keys alphabetically
        
    Returns:
        str: Template as YAML string
    """

Template Limits

Constants defining CloudFormation template limits.

MAX_RESOURCES: int = 500
MAX_PARAMETERS: int = 200
MAX_OUTPUTS: int = 200
MAX_MAPPINGS: int = 200
PARAMETER_TITLE_MAX: int = 255

Usage Examples

Basic Template Creation

from troposphere import Template, Parameter, Output, Ref
from troposphere.ec2 import Instance

# Create template with description
template = Template(Description="My CloudFormation template")

# Add parameter
instance_type = template.add_parameter(Parameter(
    "InstanceType",
    Type="String",
    Default="t2.micro",
    AllowedValues=["t2.micro", "t2.small", "t2.medium"]
))

# Add resource
instance = template.add_resource(Instance(
    "MyInstance",
    ImageId="ami-0abcdef1234567890",
    InstanceType=Ref(instance_type)
))

# Add output
template.add_output(Output(
    "InstanceId",
    Value=Ref(instance),
    Description="EC2 Instance ID"
))

# Generate CloudFormation JSON
json_template = template.to_json()
yaml_template = template.to_yaml()

Advanced Template with Conditions and Mappings

from troposphere import Template, Parameter, Condition, If, Equals, FindInMap
from troposphere.ec2 import Instance

template = Template()

# Add parameter
environment = template.add_parameter(Parameter(
    "Environment",
    Type="String",
    AllowedValues=["dev", "staging", "prod"]
))

# Add condition
template.add_condition("IsProduction", Equals(Ref(environment), "prod"))

# Add mapping
template.add_mapping("RegionMap", {
    "us-east-1": {"AMI": "ami-0ff8a91507f77f867"},
    "us-west-2": {"AMI": "ami-0bdf93799014acdc4"}
})

# Add conditional resource
instance = template.add_resource(Instance(
    "MyInstance",
    ImageId=FindInMap("RegionMap", Ref("AWS::Region"), "AMI"),
    InstanceType=If("IsProduction", "m5.large", "t2.micro")
))

Template with Parameter Groups

from troposphere import Template, Parameter

template = Template()

# Add parameters
vpc_id = template.add_parameter(Parameter(
    "VpcId",
    Type="AWS::EC2::VPC::Id",
    Description="VPC ID for resources"
))

subnet_id = template.add_parameter(Parameter(
    "SubnetId", 
    Type="AWS::EC2::Subnet::Id",
    Description="Subnet ID for instance"
))

# Group parameters
template.add_parameter_to_group(vpc_id, "Network Configuration")
template.add_parameter_to_group(subnet_id, "Network Configuration")

# Set parameter labels
template.set_parameter_label(vpc_id, "VPC")
template.set_parameter_label(subnet_id, "Subnet")

Install with Tessl CLI