stacker package

Subpackages

• stacker.actions package
  • Submodules
  • stacker.actions.base module
  • stacker.actions.build module
  • stacker.actions.destroy module
  • stacker.actions.diff module
  • stacker.actions.info module
  • Module contents
• stacker.blueprints package
  • Subpackages
    • stacker.blueprints.variables package
      • Submodules
      • stacker.blueprints.variables.types module
      • Module contents
  • Submodules
  • stacker.blueprints.base module
  • stacker.blueprints.testutil module
  • Module contents
• stacker.commands package
  • Subpackages
    • stacker.commands.stacker package
      • Submodules
      • stacker.commands.stacker.base module
      • stacker.commands.stacker.build module
      • stacker.commands.stacker.destroy module
      • stacker.commands.stacker.diff module
      • stacker.commands.stacker.info module
      • Module contents
  • Module contents
• stacker.config package
  • Subpackages
    • stacker.config.translators package
      • Submodules
      • stacker.config.translators.kms module
      • Module contents
  • Module contents
• stacker.hooks package
  • Submodules
  • stacker.hooks.aws_lambda module
  • stacker.hooks.ecs module
  • stacker.hooks.iam module
  • stacker.hooks.keypair module
  • stacker.hooks.route53 module
  • stacker.hooks.utils module
  • Module contents
• stacker.logger package
  • Submodules
  • stacker.logger.formatter module
  • stacker.logger.handler module
  • Module contents
• stacker.lookups package
  • Subpackages
    • stacker.lookups.handlers package
      • Submodules
      • stacker.lookups.handlers.ami module
      • stacker.lookups.handlers.default module
      • stacker.lookups.handlers.dynamodb module
      • stacker.lookups.handlers.envvar module
      • stacker.lookups.handlers.file module
      • stacker.lookups.handlers.hook_data module
      • stacker.lookups.handlers.kms module
      • stacker.lookups.handlers.output module
      • stacker.lookups.handlers.rxref module
      • stacker.lookups.handlers.split module
      • stacker.lookups.handlers.ssmstore module
      • stacker.lookups.handlers.xref module
      • Module contents
  • Submodules
  • stacker.lookups.registry module
  • Module contents
• stacker.providers package
  • Subpackages
    • stacker.providers.aws package
      • Submodules
      • stacker.providers.aws.default module
      • Module contents
  • Submodules
  • stacker.providers.base module
  • Module contents

Submodules

stacker.context module

class stacker.context.Context(environment=None, stack_names=None, config=None, force_stacks=None)

Bases: future.types.newobject.newobject

The context under which the current stacks are being executed.

The stacker Context is responsible for translating the values passed in via the command line and specified in the config to Stack objects.

Parameters:

• environment (dict) – A dictionary used to pass in information about the environment. Useful for templating.
• stack_names (list) – A list of stack_names to operate on. If not passed, usually all stacks defined in the config will be operated on.
• config (stacker.config.Config) – The stacker configuration being operated on.
• force_stacks (list) – A list of stacks to force work on. Used to work on locked stacks.

bucket_name

get_fqn(name=None)

Return the fully qualified name of an object within this context.

If the name passed already appears to be a fully qualified name, it will be returned with no further processing.

get_stack(name)

get_stacks()

Get the stacks for the current action.

Handles configuring the stacker.stack.Stack objects that will be used in the current action.

Returns:a list of stacker.stack.Stack objects Return type:list

get_stacks_dict()

get_targets()

Returns the named targets that are specified in the config.

Returns:a list of stacker.target.Target objects Return type:list

mappings

namespace

namespace_delimiter

set_hook_data(key, data)

Set hook data for the given key.

Parameters:

• key (str) – The key to store the hook data in.
• data (collections.Mapping) – A dictionary of data to store, as returned from a hook.

tags

template_indent

upload_templates_to_s3

stacker.context.get_fqn(base_fqn, delimiter, name=None)

Return the fully qualified name of an object within this context.

If the name passed already appears to be a fully qualified name, it will be returned with no further processing.

stacker.environment module

class stacker.environment.DictWithSourceType(source_type, *args)

Bases: dict

An environment dict which keeps track of its source.

Environment files may be loaded from simple key/value files, or from structured YAML files, and we need to render them using a different strategy based on their source. This class adds a source_type property to a dict which keeps track of whether the source for the dict is yaml or simple.

stacker.environment.parse_environment(raw_environment)

stacker.environment.parse_yaml_environment(raw_environment)

stacker.exceptions module

exception stacker.exceptions.CancelExecution

Bases: exceptions.Exception

Exception raised when we want to cancel executing the plan.

exception stacker.exceptions.ChangesetDidNotStabilize(change_set_id)

Bases: exceptions.Exception

exception stacker.exceptions.FailedLookup(lookup, error, *args, **kwargs)

Bases: exceptions.Exception

Intermediary Exception to be converted to FailedVariableLookup once it bubbles up there

exception stacker.exceptions.FailedVariableLookup(variable_name, lookup, error, *args, **kwargs)

Bases: exceptions.Exception

exception stacker.exceptions.GraphError(exception, stack, dependency)

Bases: exceptions.Exception

Raised when the graph is invalid (e.g. acyclic dependencies)

exception stacker.exceptions.ImproperlyConfigured(cls, error, *args, **kwargs)

Bases: exceptions.Exception

exception stacker.exceptions.InvalidConfig(errors)

Bases: exceptions.Exception

exception stacker.exceptions.InvalidLookupCombination(lookup, lookups, value, *args, **kwargs)

Bases: exceptions.Exception

exception stacker.exceptions.InvalidLookupConcatenation(lookup, lookups, *args, **kwargs)

Bases: exceptions.Exception

Intermediary Exception to be converted to InvalidLookupCombination once it bubbles up there

exception stacker.exceptions.InvalidUserdataPlaceholder(blueprint_name, exception_message, *args, **kwargs)

Bases: exceptions.Exception

exception stacker.exceptions.MissingEnvironment(key, *args, **kwargs)

Bases: exceptions.Exception

exception stacker.exceptions.MissingParameterException(parameters, *args, **kwargs)

Bases: exceptions.Exception

exception stacker.exceptions.MissingVariable(blueprint_name, variable_name, *args, **kwargs)

Bases: exceptions.Exception

exception stacker.exceptions.OutputDoesNotExist(stack_name, output, *args, **kwargs)

Bases: exceptions.Exception

exception stacker.exceptions.PlanFailed(failed_steps, *args, **kwargs)

Bases: exceptions.Exception

exception stacker.exceptions.StackDidNotChange

Bases: exceptions.Exception

Exception raised when there are no changes to be made by the provider.

exception stacker.exceptions.StackDoesNotExist(stack_name, *args, **kwargs)

Bases: exceptions.Exception

exception stacker.exceptions.StackUpdateBadStatus(stack_name, stack_status, reason, *args, **kwargs)

Bases: exceptions.Exception

exception stacker.exceptions.UnableToExecuteChangeSet(stack_name, change_set_id, execution_status)

Bases: exceptions.Exception

exception stacker.exceptions.UnhandledChangeSetStatus(stack_name, change_set_id, status, status_reason)

Bases: exceptions.Exception

exception stacker.exceptions.UnknownLookupType(lookup_type, *args, **kwargs)

Bases: exceptions.Exception

exception stacker.exceptions.UnresolvedVariable(blueprint_name, variable, *args, **kwargs)

Bases: exceptions.Exception

exception stacker.exceptions.UnresolvedVariableValue(lookup, *args, **kwargs)

Bases: exceptions.Exception

Intermediary Exception to be converted to UnresolvedVariable once it bubbles up there

exception stacker.exceptions.UnresolvedVariables(blueprint_name, *args, **kwargs)

Bases: exceptions.Exception

exception stacker.exceptions.ValidatorError(variable, validator, value, exception=None)

Bases: exceptions.Exception

Used for errors raised by custom validators of blueprint variables.

exception stacker.exceptions.VariableTypeRequired(blueprint_name, variable_name, *args, **kwargs)

Bases: exceptions.Exception

exception stacker.exceptions.WrongEnvironmentType(key, *args, **kwargs)

Bases: exceptions.Exception

stacker.plan module

class stacker.plan.Graph(steps=None, dag=None)

Bases: future.types.newobject.newobject

Graph represents a graph of steps.

The Graph helps organize the steps needed to execute a particular action for a set of stacker.stack.Stack objects. When initialized with a set of steps, it will first build a Directed Acyclic Graph from the steps and their dependencies.

Example:

>>> dag = DAG()
>>> a = Step("a", fn=build)
>>> b = Step("b", fn=build)
>>> dag.add_step(a)
>>> dag.add_step(b)
>>> dag.connect(a, b)

Parameters:

• steps (list) – an optional list of Step objects to execute.
• dag (stacker.dag.DAG) – an optional stacker.dag.DAG object. If one is not provided, a new one will be initialized.

add_step(step)

connect(step, dep)

downstream(step_name)

Returns the direct dependencies of the given step

filtered(step_names)

Returns a “filtered” version of this graph.

to_dict()

topological_sort()

transitive_reduction()

transposed()

Returns a “transposed” version of this graph. Useful for walking in reverse.

walk(walker, walk_func)

class stacker.plan.Plan(description, graph)

Bases: future.types.newobject.newobject

A convenience class for working on a Graph. :param description: description of the plan. :type description: str :param graph: a graph of steps. :type graph: Graph

dump(directory, context, provider=None)

execute(*args, **kwargs)

Walks each step in the underlying graph, and raises an exception if any of the steps fail.

Raises:PlanFailed – Raised if any of the steps fail.

keys()

outline(level=20, message='')

Print an outline of the actions the plan is going to take. The outline will represent the rough ordering of the steps that will be taken. :param level: a valid log level that should be used to log

the outline

Parameters:message (str, optional) – a message that will be logged to the user after the outline has been logged.

step_names

steps

walk(walker)

Walks each step in the underlying graph, in topological order.

Parameters:walker (func) – a walker function to be passed to stacker.dag.DAG to walk the graph.

class stacker.plan.Step(stack, fn, watch_func=None)

Bases: future.types.newobject.newobject

State machine for executing generic actions related to stacks. :param stack: the stack associated

with this step

Parameters:

• fn (func) – the function to run to execute the step. This function will be ran multiple times until the step is “done”.
• watch_func (func) – an optional function that will be called to “tail” the step action.

complete()

A shortcut for set_status(COMPLETE)

completed

Returns True if the step is in a COMPLETE state.

done

Returns True if the step is finished (either COMPLETE, SKIPPED or FAILED)

failed

Returns True if the step is in a FAILED state.

name

ok

Returns True if the step is finished (either COMPLETE or SKIPPED)

required_by

requires

run()

Runs this step until it has completed successfully, or been skipped.

set_status(status)

Sets the current step’s status. :param status: The status to set the

step to.

skip()

A shortcut for set_status(SKIPPED)

skipped

Returns True if the step is in a SKIPPED state.

submit()

A shortcut for set_status(SUBMITTED)

submitted

Returns True if the step is SUBMITTED, COMPLETE, or SKIPPED.

stacker.plan.build_graph(steps)

Builds a graph of steps. :param steps: a list of Step objects to execute. :type steps: list

stacker.plan.build_plan(description, graph, targets=None, reverse=False)

Builds a plan from a list of steps. :param description: an arbitrary string to

describe the plan.

Parameters:

• graph (Graph) – a list of Graph to execute.
• targets (list) – an optional list of step names to filter the graph to. If provided, only these steps, and their transitive dependencies will be executed. If no targets are specified, every node in the graph will be executed.
• reverse (bool) – If provided, the graph will be walked in reverse order (dependencies last).

stacker.plan.log_step(step)

stacker.session_cache module

stacker.session_cache.get_session(region, profile=None)

Creates a boto3 session with a cache

Parameters:

• region (str) – The region for the session
• profile (str) – The profile for the session

Returns:

A boto3 session with

credential caching

Return type:

boto3.session.Session

stacker.stack module

class stacker.stack.Stack(definition, context, variables=None, mappings=None, locked=False, force=False, enabled=True, protected=False, notification_arns=None)

Bases: future.types.newobject.newobject

Represents gathered information about a stack to be built/updated.

Parameters:

• definition (stacker.config.Stack) – A stack definition.
• context (stacker.context.Context) – Current context for building the stack.
• mappings (dict, optional) – Cloudformation mappings passed to the blueprint.
• locked (bool, optional) – Whether or not the stack is locked.
• force (bool, optional) – Whether to force updates on this stack.
• enabled (bool, optional) – Whether this stack is enabled.
• protected (boot, optional) – Whether this stack is protected.
• notification_arns (list, optional) – An optional list of SNS topic ARNs to send CloudFormation Events to.

all_parameter_definitions

Return a list of all parameters in the blueprint/template.

blueprint

parameter_values

Return all CloudFormation Parameters for the stack.

CloudFormation Parameters can be specified via Blueprint Variables with a stacker.blueprints.variables.types.CFNType type.

Returns:dictionary of <parameter name>: <parameter value>. Return type:dict

required_by

required_parameter_definitions

Return all the required CloudFormation Parameters for the stack.

requires

resolve(context, provider)

Resolve the Stack variables.

This resolves the Stack variables and then prepares the Blueprint for rendering by passing the resolved variables to the Blueprint.

Parameters:

• context (stacker.context.Context) – stacker context
• provider (stacker.provider.base.BaseProvider) – subclass of the base provider

set_outputs(outputs)

stack_policy

tags

Returns the tags that should be set on this stack. Includes both the global tags, as well as any stack specific tags or overrides.

Returns:dictionary of tags Return type:dict

stacker.status module

class stacker.status.CompleteStatus(reason=None)

Bases: stacker.status.Status

class stacker.status.DidNotChangeStatus(reason=None)

Bases: stacker.status.SkippedStatus

reason = 'nochange'

class stacker.status.FailedStatus(reason=None)

Bases: stacker.status.Status

class stacker.status.NotSubmittedStatus(reason=None)

Bases: stacker.status.SkippedStatus

reason = 'disabled'

class stacker.status.NotUpdatedStatus(reason=None)

Bases: stacker.status.SkippedStatus

reason = 'locked'

class stacker.status.PendingStatus(reason=None)

Bases: stacker.status.Status

class stacker.status.SkippedStatus(reason=None)

Bases: stacker.status.Status

class stacker.status.StackDoesNotExist(reason=None)

Bases: stacker.status.SkippedStatus

reason = 'does not exist in cloudformation'

class stacker.status.Status(name, code, reason=None)

Bases: future.types.newobject.newobject

class stacker.status.SubmittedStatus(reason=None)

Bases: stacker.status.Status

stacker.tokenize_userdata module

stacker.tokenize_userdata.cf_tokenize(s)

Parses UserData for Cloudformation helper functions.

http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/user-data.html http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference.html http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/quickref-cloudformation.html#scenario-userdata-base64

It breaks apart the given string at each recognized function (see HELPERS) and instantiates the helper function objects in place of those.

Returns a list of parts as a result. Useful when used with Join() and Base64() CloudFormation functions to produce user data.

ie: Base64(Join(‘’, cf_tokenize(userdata_string)))

stacker.util module

class stacker.util.Extractor(archive=None)

Bases: future.types.newobject.newobject

Base class for extractors.

static extension()

Serve as placeholder; override this in subclasses.

set_archive(dir_name)

Update archive filename to match directory name & extension.

Parameters:dir_name (string) – Archive directory name

class stacker.util.SOARecord(record)

Bases: future.types.newobject.newobject

Represents an SOA record.

class stacker.util.SOARecordText(record_text)

Bases: future.types.newobject.newobject

Represents the actual body of an SOARecord.

class stacker.util.SourceProcessor(sources, stacker_cache_dir=None)

Bases: future.types.newobject.newobject

Makes remote python package sources available in current environment.

ISO8601_FORMAT = '%Y%m%dT%H%M%SZ'

create_cache_directories()

Ensure that SourceProcessor cache directories exist.

determine_git_ls_remote_ref(config)

Determine the ref to be used with the “git ls-remote” command.

Parameters:config (stacker.config.GitPackageSource) – git config dictionary; ‘branch’ key is optional Returns:A branch reference or “HEAD” Return type:str

determine_git_ref(config)

Determine the ref to be used for ‘git checkout’.

Parameters:config (dict) – git config dictionary Returns:A commit id or tag name Return type:str

fetch_git_package(config)

Make a remote git repository available for local use.

Parameters:config (dict) – git config dictionary

fetch_local_package(config)

Make a local path available to current stacker config.

Parameters:config (dict) – ‘local’ path config dictionary

fetch_s3_package(config)

Make a remote S3 archive available for local use.

Parameters:config (dict) – git config dictionary

get_package_sources()

Make remote python packages available for local use.

git_ls_remote(uri, ref)

Determine the latest commit id for a given ref.

Parameters:

• uri (string) – git URI
• ref (string) – git ref

Returns:

A commit id

Return type:

str

sanitize_git_path(uri, ref=None)

Take a git URI and ref and converts it to a directory safe path.

Parameters:

• uri (string) – git URI (e.g. git@github.com:foo/bar.git)
• ref (string) – optional git ref to be appended to the path

Returns:

Directory name for the supplied uri

Return type:

str

sanitize_uri_path(uri)

Take a URI and converts it to a directory safe path.

Parameters:uri (string) – URI (e.g. http://example.com/cats) Returns:Directory name for the supplied uri Return type:str

update_paths_and_config(config, pkg_dir_name, pkg_cache_dir=None)

Handle remote source defined sys.paths & configs.

Parameters:

• config (dict) – git config dictionary
• pkg_dir_name (string) – directory name of the stacker archive
• pkg_cache_dir (string) – fully qualified path to stacker cache cache directory

class stacker.util.TarExtractor(archive=None)

Bases: stacker.util.Extractor

Extracts tar archives.

static extension()

Return archive extension.

extract(destination)

Extract the archive.

class stacker.util.TarGzipExtractor(archive=None)

Bases: stacker.util.Extractor

Extracts compressed tar archives.

static extension()

Return archive extension.

extract(destination)

Extract the archive.

class stacker.util.ZipExtractor(archive=None)

Bases: stacker.util.Extractor

Extracts zip archives.

static extension()

Return archive extension.

extract(destination)

Extract the archive.

stacker.util.camel_to_snake(name)

Converts CamelCase to snake_case.

Parameters:name (string) – The name to convert from CamelCase to snake_case. Returns:Converted string. Return type:string

stacker.util.cf_safe_name(name)

Converts a name to a safe string for a Cloudformation resource.

Given a string, returns a name that is safe for use as a CloudFormation Resource. (ie: Only alphanumeric characters)

stacker.util.convert_class_name(kls)

Gets a string that represents a given class.

Parameters:kls (class) – The class being analyzed for its name. Returns:The name of the given kls. Return type:string

stacker.util.create_route53_zone(client, zone_name)

Creates the given zone_name if it doesn’t already exists.

Also sets the SOA negative caching TTL to something short (300 seconds).

Parameters:

• client (botocore.client.Route53) – The connection used to interact with Route53’s API.
• zone_name (string) – The name of the DNS hosted zone to create.

Returns:

The zone id returned from AWS for the existing, or newly

created zone.

Return type:

string

stacker.util.ensure_s3_bucket(s3_client, bucket_name, bucket_region)

Ensure an s3 bucket exists, if it does not then create it.

Parameters:

• s3_client (botocore.client.Client) – An s3 client used to verify and create the bucket.
• bucket_name (str) – The bucket being checked/created.
• bucket_region (str, optional) – The region to create the bucket in. If not provided, will be determined by s3_client’s region.

stacker.util.get_client_region(client)

Gets the region from a boto3.client.Client object.

Parameters:client (boto3.client.Client) – The client to get the region from. Returns:AWS region string. Return type:string

stacker.util.get_config_directory()

Return the directory the config file is located in.

This enables us to use relative paths in config values.

stacker.util.get_hosted_zone_by_name(client, zone_name)

Get the zone id of an existing zone by name.

Parameters:

• client (botocore.client.Route53) – The connection used to interact with Route53’s API.
• zone_name (string) – The name of the DNS hosted zone to create.

Returns:

The Id of the Hosted Zone.

Return type:

string

stacker.util.get_or_create_hosted_zone(client, zone_name)

Get the Id of an existing zone, or create it.

Parameters:

• client (botocore.client.Route53) – The connection used to interact with Route53’s API.
• zone_name (string) – The name of the DNS hosted zone to create.

Returns:

The Id of the Hosted Zone.

Return type:

string

stacker.util.get_s3_endpoint(client)

Gets the s3 endpoint for the given boto3.client.Client object.

Parameters:client (boto3.client.Client) – The client to get the endpoint from. Returns:The AWS endpoint for the client. Return type:string

stacker.util.get_soa_record(client, zone_id, zone_name)

Gets the SOA record for zone_name from zone_id.

Parameters:

• client (botocore.client.Route53) – The connection used to interact with Route53’s API.
• zone_id (string) – The AWS Route53 zone id of the hosted zone to query.
• zone_name (string) – The name of the DNS hosted zone to create.

Returns:

An object representing the parsed SOA

record returned from AWS Route53.

Return type:

stacker.util.SOARecord

stacker.util.load_object_from_string(fqcn)

Converts “.” delimited strings to a python object.

Given a “.” delimited string representing the full path to an object (function, class, variable) inside a module, return that object. Example:

load_object_from_string(“os.path.basename”) load_object_from_string(“logging.Logger”) load_object_from_string(“LocalClassName”)

stacker.util.merge_map(a, b)

Recursively merge elements of argument b into argument a.

Primarly used for merging two dictionaries together, where dict b takes precedence over dict a. If 2 lists are provided, they are concatenated.

stacker.util.parse_cloudformation_template(template)

Parse CFN template string.

Leverages the vendored aws-cli yamlhelper to handle JSON or YAML templates.

Parameters:template (str) – The template body.

stacker.util.parse_zone_id(full_zone_id)

Parses the returned hosted zone id and returns only the ID itself.

stacker.util.read_value_from_path(value)

Enables translators to read values from files.

The value can be referred to with the file:// prefix. ie:

conf_key: ${kms file://kms_value.txt}

stacker.util.s3_bucket_location_constraint(region)

Returns the appropriate LocationConstraint info for a new S3 bucket.

When creating a bucket in a region OTHER than us-east-1, you need to specify a LocationConstraint inside the CreateBucketConfiguration argument. This function helps you determine the right value given a given client.

Parameters:region (str) – The region where the bucket will be created in. Returns:The string to use with the given client for creating a bucket. Return type:string

stacker.util.stack_template_key_name(blueprint)

Given a blueprint, produce an appropriate key name.

Parameters:blueprint (stacker.blueprints.base.Blueprint) – The blueprint object to create the key from. Returns:Key name resulting from blueprint. Return type:string

stacker.util.uppercase_first_letter(s)

Return string “s” with first character upper case.

stacker.util.yaml_to_ordered_dict(stream, loader=<class 'yaml.loader.SafeLoader'>)

Provides yaml.load alternative with preserved dictionary order.

Parameters:

• stream (string) – YAML string to load.
• loader (yaml.loader) – PyYAML loader class. Defaults to safe load.

Returns:

Parsed YAML.

Return type:

OrderedDict

stacker.variables module

class stacker.variables.LookupTemplate(template)

Bases: string.Template

A custom string template we use to replace lookup values

idpattern = '[_a-z][^\\$\\{\\}]*'

pattern = <_sre.SRE_Pattern object>

class stacker.variables.Variable(name, value)

Bases: future.types.newobject.newobject

Represents a variable passed to a stack.

Parameters:

• name (str) – Name of the variable
• value (any) – Initial value of the variable from the config (str, list, dict)

dependencies()

Returns:Stack names that this variable depends on Return type:Set[str]

resolve(context, provider)

Recursively resolve any lookups with the Variable.

Parameters:

• context (stacker.context.Context) – Current context for building the stack
• provider (stacker.provider.base.BaseProvider) – subclass of the base provider

resolved

Boolean for whether the Variable has been resolved.

Variables only need to be resolved if they contain lookups.

value

Return the current value of the Variable.

class stacker.variables.VariableValue

Bases: future.types.newobject.newobject

Abstract Syntax Tree base object to parse the value for a variable

dependencies()

classmethod parse(input_object)

resolve(context, provider)

resolved()

Returns:Whether value() will not raise an error Return type:bool

simplified()

Return a simplified version of the Value. This can be used to e.g. concatenate two literals in to one literal, or to flatten nested Concatenations

Returns:VariableValue

value()

class stacker.variables.VariableValueConcatenation

Bases: stacker.variables.VariableValue, list

dependencies()

resolve(context, provider)

resolved()

Returns: bool: Whether value() will not raise an error

simplified()

Return a simplified version of the Value. This can be used to e.g. concatenate two literals in to one literal, or to flatten nested Concatenations

Returns:VariableValue

value()

class stacker.variables.VariableValueDict

Bases: stacker.variables.VariableValue, dict

dependencies()

classmethod parse(input_object)

resolve(context, provider)

resolved()

Returns: bool: Whether value() will not raise an error

simplified()

Return a simplified version of the Value. This can be used to e.g. concatenate two literals in to one literal, or to flatten nested Concatenations

Returns:VariableValue

value()

class stacker.variables.VariableValueList

Bases: stacker.variables.VariableValue, list

dependencies()

classmethod parse(input_object)

resolve(context, provider)

resolved()

Returns: bool: Whether value() will not raise an error

simplified()

Return a simplified version of the Value. This can be used to e.g. concatenate two literals in to one literal, or to flatten nested Concatenations

Returns:VariableValue

value()

class stacker.variables.VariableValueLiteral(value)

Bases: stacker.variables.VariableValue

resolved()

Returns: bool: Whether value() will not raise an error

value()

class stacker.variables.VariableValueLookup(lookup_name, lookup_data, handler=None)

Bases: stacker.variables.VariableValue

dependencies()

resolve(context, provider)

resolved()

Returns: bool: Whether value() will not raise an error

simplified()

Return a simplified version of the Value. This can be used to e.g. concatenate two literals in to one literal, or to flatten nested Concatenations

Returns:VariableValue

value()

stacker.variables.resolve_variables(variables, context, provider)

Given a list of variables, resolve all of them.

Parameters:

• variables (list of stacker.variables.Variable) – list of variables
• context (stacker.context.Context) – stacker context
• provider (stacker.provider.base.BaseProvider) – subclass of the base provider

Module contents