Add files using upload-large-folder tool

data/lib/python3.10/site-packages/awscli/bcdoc/__init__.py

@@ -0,0 +1,13 @@
+# Copyright 2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+__version__ = '0.16.0'

data/lib/python3.10/site-packages/awscli/bcdoc/docevents.py

@@ -0,0 +1,106 @@
+# Copyright 2012-2015 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+
+DOC_EVENTS = {
+    'doc-breadcrumbs': '.%s',
+    'doc-title': '.%s',
+    'doc-description': '.%s',
+    'doc-synopsis-start': '.%s',
+    'doc-synopsis-option': '.%s.%s',
+    'doc-synopsis-end': '.%s',
+    'doc-options-start': '.%s',
+    'doc-option': '.%s.%s',
+    'doc-option-example': '.%s.%s',
+    'doc-options-end': '.%s',
+    'doc-global-option': '.%s',
+    'doc-examples': '.%s',
+    'doc-output': '.%s',
+    'doc-subitems-start': '.%s',
+    'doc-subitem': '.%s.%s',
+    'doc-subitems-end': '.%s',
+    'doc-relateditems-start': '.%s',
+    'doc-relateditem': '.%s.%s',
+    'doc-relateditems-end': '.%s'
+    }
+
+
+def generate_events(session, help_command):
+    # Now generate the documentation events
+    session.emit('doc-breadcrumbs.%s' % help_command.event_class,
+                 help_command=help_command)
+    session.emit('doc-title.%s' % help_command.event_class,
+                 help_command=help_command)
+    session.emit('doc-description.%s' % help_command.event_class,
+                 help_command=help_command)
+    session.emit('doc-synopsis-start.%s' % help_command.event_class,
+                 help_command=help_command)
+    if help_command.arg_table:
+        for arg_name in help_command.arg_table:
+            # An argument can set an '_UNDOCUMENTED' attribute
+            # to True to indicate a parameter that exists
+            # but shouldn't be documented.  This can be used
+            # for backwards compatibility of deprecated arguments.
+            if getattr(help_command.arg_table[arg_name],
+                       '_UNDOCUMENTED', False):
+                continue
+            session.emit(
+                'doc-synopsis-option.%s.%s' % (help_command.event_class,
+                                               arg_name),
+                arg_name=arg_name, help_command=help_command)
+    session.emit('doc-synopsis-end.%s' % help_command.event_class,
+                 help_command=help_command)
+    session.emit('doc-options-start.%s' % help_command.event_class,
+                 help_command=help_command)
+    if help_command.arg_table:
+        for arg_name in help_command.arg_table:
+            if getattr(help_command.arg_table[arg_name],
+                       '_UNDOCUMENTED', False):
+                continue
+            session.emit('doc-option.%s.%s' % (help_command.event_class,
+                                               arg_name),
+                         arg_name=arg_name, help_command=help_command)
+            session.emit('doc-option-example.%s.%s' %
+                         (help_command.event_class, arg_name),
+                         arg_name=arg_name, help_command=help_command)
+    session.emit('doc-options-end.%s' % help_command.event_class,
+                 help_command=help_command)
+    session.emit('doc-global-option.%s' % help_command.event_class,
+                 help_command=help_command)
+    session.emit('doc-subitems-start.%s' % help_command.event_class,
+                 help_command=help_command)
+    if help_command.command_table:
+        for command_name in sorted(help_command.command_table.keys()):
+            if hasattr(help_command.command_table[command_name],
+                       '_UNDOCUMENTED'):
+                continue
+            session.emit('doc-subitem.%s.%s'
+                         % (help_command.event_class, command_name),
+                         command_name=command_name,
+                         help_command=help_command)
+    session.emit('doc-subitems-end.%s' % help_command.event_class,
+                 help_command=help_command)
+    session.emit('doc-examples.%s' % help_command.event_class,
+                 help_command=help_command)
+    session.emit('doc-output.%s' % help_command.event_class,
+                 help_command=help_command)
+    session.emit('doc-relateditems-start.%s' % help_command.event_class,
+                 help_command=help_command)
+    if help_command.related_items:
+        for related_item in sorted(help_command.related_items):
+            session.emit('doc-relateditem.%s.%s'
+                         % (help_command.event_class, related_item),
+                         help_command=help_command,
+                         related_item=related_item)
+    session.emit('doc-relateditems-end.%s' % help_command.event_class,
+                 help_command=help_command)

data/lib/python3.10/site-packages/awscli/bcdoc/docstringparser.py

@@ -0,0 +1,203 @@
+# Copyright 2012-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+from html.parser import HTMLParser
+
+
+class DocStringParser(HTMLParser):
+    """
+    A simple HTML parser.  Focused on converting the subset of HTML
+    that appears in the documentation strings of the JSON models into
+    simple ReST format.
+    """
+
+    def __init__(self, doc):
+        self.tree = None
+        self.doc = doc
+        HTMLParser.__init__(self)
+
+    def reset(self):
+        HTMLParser.reset(self)
+        self.tree = HTMLTree(self.doc)
+
+    def feed(self, data):
+        # HTMLParser is an old style class, so the super() method will not work.
+        HTMLParser.feed(self, data)
+        self.tree.write()
+        self.tree = HTMLTree(self.doc)
+
+    def close(self):
+        HTMLParser.close(self)
+        # Write if there is anything remaining.
+        self.tree.write()
+        self.tree = HTMLTree(self.doc)
+
+    def handle_starttag(self, tag, attrs):
+        self.tree.add_tag(tag, attrs=attrs)
+
+    def handle_endtag(self, tag):
+        self.tree.add_tag(tag, is_start=False)
+
+    def handle_data(self, data):
+        self.tree.add_data(data)
+
+
+class HTMLTree:
+    """
+    A tree which handles HTML nodes. Designed to work with a python HTML parser,
+    meaning that the current_node will be the most recently opened tag. When
+    a tag is closed, the current_node moves up to the parent node.
+    """
+
+    def __init__(self, doc):
+        self.doc = doc
+        self.head = StemNode()
+        self.current_node = self.head
+        self.unhandled_tags = []
+
+    def add_tag(self, tag, attrs=None, is_start=True):
+        if not self._doc_has_handler(tag, is_start):
+            self.unhandled_tags.append(tag)
+            return
+
+        if is_start:
+            if tag == 'li':
+                node = LineItemNode(attrs)
+            else:
+                node = TagNode(tag, attrs)
+            self.current_node.add_child(node)
+            self.current_node = node
+        else:
+            self.current_node = self.current_node.parent
+
+    def _doc_has_handler(self, tag, is_start):
+        if is_start:
+            handler_name = 'start_%s' % tag
+        else:
+            handler_name = 'end_%s' % tag
+
+        return hasattr(self.doc.style, handler_name)
+
+    def add_data(self, data):
+        self.current_node.add_child(DataNode(data))
+
+    def write(self):
+        self.head.write(self.doc)
+
+
+class Node:
+    def __init__(self, parent=None):
+        self.parent = parent
+
+    def write(self, doc):
+        raise NotImplementedError
+
+
+class StemNode(Node):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.children = []
+
+    def add_child(self, child):
+        child.parent = self
+        self.children.append(child)
+
+    def write(self, doc):
+        self._write_children(doc)
+
+    def _write_children(self, doc):
+        for child in self.children:
+            child.write(doc)
+
+
+class TagNode(StemNode):
+    """
+    A generic Tag node. It will verify that handlers exist before writing.
+    """
+
+    def __init__(self, tag, attrs=None, parent=None):
+        super().__init__(parent)
+        self.attrs = attrs
+        self.tag = tag
+
+    def write(self, doc):
+        self._write_start(doc)
+        self._write_children(doc)
+        self._write_end(doc)
+
+    def _write_start(self, doc):
+        handler_name = 'start_%s' % self.tag
+        if hasattr(doc.style, handler_name):
+            getattr(doc.style, handler_name)(self.attrs)
+
+    def _write_end(self, doc):
+        handler_name = 'end_%s' % self.tag
+        if hasattr(doc.style, handler_name):
+            getattr(doc.style, handler_name)()
+
+
+class LineItemNode(TagNode):
+    def __init__(self, attrs=None, parent=None):
+        super().__init__('li', attrs, parent)
+
+    def write(self, doc):
+        self._lstrip(self)
+        super().write(doc)
+
+    def _lstrip(self, node):
+        """
+        Traverses the tree, stripping out whitespace until text data is found
+        :param node: The node to strip
+        :return: True if non-whitespace data was found, False otherwise
+        """
+        for child in node.children:
+            if isinstance(child, DataNode):
+                child.lstrip()
+                if child.data:
+                    return True
+            else:
+                found = self._lstrip(child)
+                if found:
+                    return True
+
+        return False
+
+
+class DataNode(Node):
+    """
+    A Node that contains only string data.
+    """
+
+    def __init__(self, data, parent=None):
+        super().__init__(parent)
+        if not isinstance(data, str):
+            raise ValueError("Expecting string type, %s given." % type(data))
+        self.data = data
+
+    def lstrip(self):
+        self.data = self.data.lstrip()
+
+    def write(self, doc):
+        if not self.data:
+            return
+
+        if self.data.isspace():
+            str_data = ' '
+        else:
+            end_space = self.data[-1].isspace()
+            words = self.data.split()
+            words = doc.translate_words(words)
+            str_data = ' '.join(words)
+            if end_space:
+                str_data += ' '
+
+        doc.handle_data(str_data)

data/lib/python3.10/site-packages/awscli/bcdoc/restdoc.py

@@ -0,0 +1,240 @@
+# Copyright 2012-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+import logging
+
+from botocore.compat import OrderedDict
+from awscli.bcdoc.docstringparser import DocStringParser
+from awscli.bcdoc.style import ReSTStyle
+
+LOG = logging.getLogger('bcdocs')
+
+
+class ReSTDocument(object):
+
+    def __init__(self, target='man'):
+        self.style = ReSTStyle(self)
+        self.target = target
+        self.parser = DocStringParser(self)
+        self.keep_data = True
+        self.do_translation = False
+        self.translation_map = {}
+        self.hrefs = {}
+        self._writes = []
+        self._last_doc_string = None
+
+    def _write(self, s):
+        if self.keep_data and s is not None:
+            self._writes.append(s)
+
+    def write(self, content):
+        """
+        Write content into the document.
+        """
+        self._write(content)
+
+    def writeln(self, content):
+        """
+        Write content on a newline.
+        """
+        self._write('%s%s\n' % (self.style.spaces(), content))
+
+    def peek_write(self):
+        """
+        Returns the last content written to the document without
+        removing it from the stack.
+        """
+        return self._writes[-1]
+
+    def pop_write(self):
+        """
+        Removes and returns the last content written to the stack.
+        """
+        return self._writes.pop()
+
+    def push_write(self, s):
+        """
+        Places new content on the stack.
+        """
+        self._writes.append(s)
+
+    def find_last_write(self, content):
+        """
+        Returns the index of the last occurrence of the content argument
+        in the stack, or returns None if content is not on the stack.
+        """
+        try:
+            return len(self._writes) - self._writes[::-1].index(content) - 1
+        except ValueError:
+            return None
+
+    def insert_write(self, index, content):
+        """
+        Inserts the content argument to the stack directly before the
+        supplied index.
+        """
+        self._writes.insert(index, content)
+
+    def getvalue(self):
+        """
+        Returns the current content of the document as a string.
+        """
+        if self.hrefs:
+            self.style.new_paragraph()
+            for refname, link in self.hrefs.items():
+                self.style.link_target_definition(refname, link)
+        return ''.join(self._writes).encode('utf-8')
+
+    def translate_words(self, words):
+        return [self.translation_map.get(w, w) for w in words]
+
+    def handle_data(self, data):
+        if data and self.keep_data:
+            self._write(data)
+
+    def include_doc_string(self, doc_string):
+        if doc_string:
+            try:
+                start = len(self._writes)
+                self.parser.feed(doc_string)
+                self.parser.close()
+                end = len(self._writes)
+                self._last_doc_string = (start, end)
+            except Exception:
+                LOG.debug('Error parsing doc string', exc_info=True)
+                LOG.debug(doc_string)
+
+    def remove_last_doc_string(self):
+        # Removes all writes inserted by last doc string
+        if self._last_doc_string is not None:
+            start, end = self._last_doc_string
+            del self._writes[start:end]
+
+    def write_from_file(self, filename):
+        with open(filename, 'r') as f:
+            for line in f.readlines():
+                self.writeln(line.strip())
+
+
+class DocumentStructure(ReSTDocument):
+    def __init__(self, name, section_names=None, target='man', context=None):
+        """Provides a Hierarichial structure to a ReSTDocument
+
+        You can write to it similiar to as you can to a ReSTDocument but
+        has an innate structure for more orginaztion and abstraction.
+
+        :param name: The name of the document
+        :param section_names: A list of sections to be included
+            in the document.
+        :param target: The target documentation of the Document structure
+        :param context: A dictionary of data to store with the strucuture. These
+            are only stored per section not the entire structure.
+        """
+        super(DocumentStructure, self).__init__(target=target)
+        self._name = name
+        self._structure = OrderedDict()
+        self._path = [self._name]
+        self._context = {}
+        if context is not None:
+            self._context = context
+        if section_names is not None:
+            self._generate_structure(section_names)
+
+    @property
+    def name(self):
+        """The name of the document structure"""
+        return self._name
+
+    @property
+    def path(self):
+        """
+        A list of where to find a particular document structure in the
+        overlying document structure.
+        """
+        return self._path
+
+    @path.setter
+    def path(self, value):
+        self._path = value
+
+    @property
+    def available_sections(self):
+        return list(self._structure)
+
+    @property
+    def context(self):
+        return self._context
+
+    def _generate_structure(self, section_names):
+        for section_name in section_names:
+            self.add_new_section(section_name)
+
+    def add_new_section(self, name, context=None):
+        """Adds a new section to the current document structure
+
+        This document structure will be considered a section to the
+        current document structure but will in itself be an entirely
+        new document structure that can be written to and have sections
+        as well
+
+        :param name: The name of the section.
+        :param context: A dictionary of data to store with the strucuture. These
+            are only stored per section not the entire structure.
+        :rtype: DocumentStructure
+        :returns: A new document structure to add to but lives as a section
+            to the document structure it was instantiated from.
+        """
+        # Add a new section
+        section = self.__class__(name=name, target=self.target,
+                                 context=context)
+        section.path = self.path + [name]
+        # Indent the section apporpriately as well
+        section.style.indentation = self.style.indentation
+        section.translation_map = self.translation_map
+        section.hrefs = self.hrefs
+        self._structure[name] = section
+        return section
+
+    def get_section(self, name):
+        """Retrieve a section"""
+        return self._structure[name]
+
+    def delete_section(self, name):
+        """Delete a section"""
+        del self._structure[name]
+
+    def flush_structure(self):
+        """Flushes a doc structure to a ReSTructed string
+
+        The document is flushed out in a DFS style where sections and their
+        subsections' values are added to the string as they are visited.
+        """
+        # We are at the root flush the links at the beginning of the
+        # document
+        if len(self.path) == 1:
+            if self.hrefs:
+                self.style.new_paragraph()
+                for refname, link in self.hrefs.items():
+                    self.style.link_target_definition(refname, link)
+        value = self.getvalue()
+        for name, section in self._structure.items():
+            value += section.flush_structure()
+        return value
+
+    def getvalue(self):
+        return ''.join(self._writes).encode('utf-8')
+
+    def remove_all_sections(self):
+        self._structure = OrderedDict()
+
+    def clear_text(self):
+        self._writes = []

data/lib/python3.10/site-packages/awscli/bcdoc/style.py

@@ -0,0 +1,418 @@
+# Copyright 2012-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+import logging
+
+logger = logging.getLogger('bcdocs')
+
+
+class BaseStyle(object):
+
+    def __init__(self, doc, indent_width=2):
+        self.doc = doc
+        self.indent_width = indent_width
+        self._indent = 0
+        self.keep_data = True
+
+    @property
+    def indentation(self):
+        return self._indent
+
+    @indentation.setter
+    def indentation(self, value):
+        self._indent = value
+
+    def new_paragraph(self):
+        return '\n%s' % self.spaces()
+
+    def indent(self):
+        self._indent += 1
+
+    def dedent(self):
+        if self._indent > 0:
+            self._indent -= 1
+
+    def spaces(self):
+        return ' ' * (self._indent * self.indent_width)
+
+    def bold(self, s):
+        return s
+
+    def ref(self, link, title=None):
+        return link
+
+    def h2(self, s):
+        return s
+
+    def h3(self, s):
+        return s
+
+    def underline(self, s):
+        return s
+
+    def italics(self, s):
+        return s
+
+
+class ReSTStyle(BaseStyle):
+
+    def __init__(self, doc, indent_width=2):
+        BaseStyle.__init__(self, doc, indent_width)
+        self.do_p = True
+        self.a_href = None
+        self.list_depth = 0
+
+    def new_paragraph(self):
+        self.doc.write('\n\n%s' % self.spaces())
+
+    def new_line(self):
+        self.doc.write('\n%s' % self.spaces())
+
+    def _start_inline(self, markup):
+        self.doc.write(markup)
+
+    def _end_inline(self, markup):
+        # Sometimes the HTML markup has whitespace between the end
+        # of the text inside the inline markup and the closing element
+        # (e.g. <b>foobar </b>).  This trailing space will cause
+        # problems in the ReST inline markup so we remove it here
+        # by popping the last item written off the stack, striping
+        # the whitespace and then pushing it back on the stack.
+        last_write = self.doc.pop_write().rstrip(' ')
+
+        # Sometimes, for whatever reason, a tag like <b/> is present. This
+        # is problematic because if we simply translate that directly then
+        # we end up with something like ****, which rst will assume is a
+        # heading instead of an empty bold.
+        if last_write == markup:
+            return
+
+        self.doc.push_write(last_write)
+        self.doc.write(markup + ' ')
+
+    def start_bold(self, attrs=None):
+        self._start_inline('**')
+
+    def end_bold(self):
+        self._end_inline('**')
+
+    def start_b(self, attrs=None):
+        self.doc.do_translation = True
+        self.start_bold(attrs)
+
+    def end_b(self):
+        self.doc.do_translation = False
+        self.end_bold()
+
+    def bold(self, s):
+        if s:
+            self.start_bold()
+            self.doc.write(s)
+            self.end_bold()
+
+    def ref(self, title, link=None):
+        if link is None:
+            link = title
+        self.doc.write(':doc:`%s <%s>`' % (title, link))
+
+    def _heading(self, s, border_char):
+        border = border_char * len(s)
+        self.new_paragraph()
+        self.doc.write('%s\n%s\n%s' % (border, s, border))
+        self.new_paragraph()
+
+    def h1(self, s):
+        self._heading(s, '*')
+
+    def h2(self, s):
+        self._heading(s, '=')
+
+    def h3(self, s):
+        self._heading(s, '-')
+
+    def start_italics(self, attrs=None):
+        self._start_inline('*')
+
+    def end_italics(self):
+        self._end_inline('*')
+
+    def italics(self, s):
+        if s:
+            self.start_italics()
+            self.doc.write(s)
+            self.end_italics()
+
+    def start_p(self, attrs=None):
+        if self.do_p:
+            self.doc.write('\n\n%s' % self.spaces())
+
+    def end_p(self):
+        if self.do_p:
+            self.doc.write('\n\n%s' % self.spaces())
+
+    def start_code(self, attrs=None):
+        self.doc.do_translation = True
+        self._start_inline('``')
+
+    def end_code(self):
+        self.doc.do_translation = False
+        self._end_inline('``')
+
+    def code(self, s):
+        if s:
+            self.start_code()
+            self.doc.write(s)
+            self.end_code()
+
+    def start_note(self, attrs=None):
+        self.new_paragraph()
+        self.doc.write('.. note::')
+        self.indent()
+        self.new_paragraph()
+
+    def end_note(self):
+        self.dedent()
+        self.new_paragraph()
+
+    def start_important(self, attrs=None):
+        self.new_paragraph()
+        self.doc.write('.. warning::')
+        self.indent()
+        self.new_paragraph()
+
+    def end_important(self):
+        self.dedent()
+        self.new_paragraph()
+
+    def start_danger(self, attrs=None):
+        self.new_paragraph()
+        self.doc.write('.. danger::')
+        self.indent()
+        self.new_paragraph()
+
+    def end_danger(self):
+        self.dedent()
+        self.new_paragraph()
+
+    def start_a(self, attrs=None):
+        if attrs:
+            for attr_key, attr_value in attrs:
+                if attr_key == 'href':
+                    self.a_href = attr_value
+                    self.doc.write('`')
+        else:
+            # There are some model documentation that
+            # looks like this: <a>DescribeInstances</a>.
+            # In this case we just write out an empty
+            # string.
+            self.doc.write(' ')
+        self.doc.do_translation = True
+
+    def link_target_definition(self, refname, link):
+        self.doc.writeln('.. _%s: %s' % (refname, link))
+
+    def sphinx_reference_label(self, label, text=None):
+        if text is None:
+            text = label
+        if self.doc.target == 'html':
+            self.doc.write(':ref:`%s <%s>`' % (text, label))
+        else:
+            self.doc.write(text)
+
+    def end_a(self):
+        self.doc.do_translation = False
+        if self.a_href:
+            last_write = self.doc.pop_write()
+            last_write = last_write.rstrip(' ')
+            if last_write and last_write != '`':
+                if ':' in last_write:
+                    last_write = last_write.replace(':', r'\:')
+                self.doc.push_write(last_write)
+                self.doc.push_write(' <%s>`__' % self.a_href)
+            elif last_write == '`':
+                # Look at start_a().  It will do a self.doc.write('`')
+                # which is the start of the link title.  If that is the
+                # case then there was no link text.  We should just
+                # use an inline link.  The syntax of this is
+                # `<http://url>`_
+                self.doc.push_write('`<%s>`__' % self.a_href)
+            else:
+                self.doc.push_write(self.a_href)
+                self.doc.hrefs[self.a_href] = self.a_href
+                self.doc.write('`__')
+            self.a_href = None
+        self.doc.write(' ')
+
+    def start_i(self, attrs=None):
+        self.doc.do_translation = True
+        self.start_italics()
+
+    def end_i(self):
+        self.doc.do_translation = False
+        self.end_italics()
+
+    def start_li(self, attrs=None):
+        self.new_line()
+        self.do_p = False
+        self.doc.write('* ')
+
+    def end_li(self):
+        self.do_p = True
+        self.new_line()
+
+    def li(self, s):
+        if s:
+            self.start_li()
+            self.doc.writeln(s)
+            self.end_li()
+
+    def start_ul(self, attrs=None):
+        if self.list_depth != 0:
+            self.indent()
+        self.list_depth += 1
+        self.new_paragraph()
+
+    def end_ul(self):
+        self.list_depth -= 1
+        if self.list_depth != 0:
+            self.dedent()
+        self.new_paragraph()
+
+    def start_ol(self, attrs=None):
+        # TODO: Need to control the bullets used for LI items
+        if self.list_depth != 0:
+            self.indent()
+        self.list_depth += 1
+        self.new_paragraph()
+
+    def end_ol(self):
+        self.list_depth -= 1
+        if self.list_depth != 0:
+            self.dedent()
+        self.new_paragraph()
+
+    def start_examples(self, attrs=None):
+        self.doc.keep_data = False
+
+    def end_examples(self):
+        self.doc.keep_data = True
+
+    def start_fullname(self, attrs=None):
+        self.doc.keep_data = False
+
+    def end_fullname(self):
+        self.doc.keep_data = True
+
+    def start_codeblock(self, attrs=None):
+        self.doc.write('::')
+        self.indent()
+        self.new_paragraph()
+
+    def end_codeblock(self):
+        self.dedent()
+        self.new_paragraph()
+
+    def codeblock(self, code):
+        """
+        Literal code blocks are introduced by ending a paragraph with
+        the special marker ::.  The literal block must be indented
+        (and, like all paragraphs, separated from the surrounding
+        ones by blank lines).
+        """
+        self.start_codeblock()
+        self.doc.writeln(code)
+        self.end_codeblock()
+
+    def toctree(self):
+        if self.doc.target == 'html':
+            self.doc.write('\n.. toctree::\n')
+            self.doc.write('  :maxdepth: 1\n')
+            self.doc.write('  :titlesonly:\n\n')
+        else:
+            self.start_ul()
+
+    def tocitem(self, item, file_name=None):
+        if self.doc.target == 'man':
+            self.li(item)
+        else:
+            if file_name:
+                self.doc.writeln('  %s' % file_name)
+            else:
+                self.doc.writeln('  %s' % item)
+
+    def hidden_toctree(self):
+        if self.doc.target == 'html':
+            self.doc.write('\n.. toctree::\n')
+            self.doc.write('  :maxdepth: 1\n')
+            self.doc.write('  :hidden:\n\n')
+
+    def hidden_tocitem(self, item):
+        if self.doc.target == 'html':
+            self.tocitem(item)
+
+    def table_of_contents(self, title=None, depth=None):
+        self.doc.write('.. contents:: ')
+        if title is not None:
+            self.doc.writeln(title)
+        if depth is not None:
+            self.doc.writeln('   :depth: %s' % depth)
+
+    def start_sphinx_py_class(self, class_name):
+        self.new_paragraph()
+        self.doc.write('.. py:class:: %s' % class_name)
+        self.indent()
+        self.new_paragraph()
+
+    def end_sphinx_py_class(self):
+        self.dedent()
+        self.new_paragraph()
+
+    def start_sphinx_py_method(self, method_name, parameters=None):
+        self.new_paragraph()
+        content = '.. py:method:: %s' % method_name
+        if parameters is not None:
+            content += '(%s)' % parameters
+        self.doc.write(content)
+        self.indent()
+        self.new_paragraph()
+
+    def end_sphinx_py_method(self):
+        self.dedent()
+        self.new_paragraph()
+
+    def start_sphinx_py_attr(self, attr_name):
+        self.new_paragraph()
+        self.doc.write('.. py:attribute:: %s' % attr_name)
+        self.indent()
+        self.new_paragraph()
+
+    def end_sphinx_py_attr(self):
+        self.dedent()
+        self.new_paragraph()
+
+    def write_py_doc_string(self, docstring):
+        docstring_lines = docstring.splitlines()
+        for docstring_line in docstring_lines:
+            self.doc.writeln(docstring_line)
+
+    def external_link(self, title, link):
+        if self.doc.target == 'html':
+            self.doc.write('`%s <%s>`_' % (title, link))
+        else:
+            self.doc.write(title)
+
+    def internal_link(self, title, page):
+        if self.doc.target == 'html':
+            self.doc.write(':doc:`%s <%s>`' % (title, page))
+        else:
+            self.doc.write(title)

data/lib/python3.10/site-packages/awscli/bcdoc/textwriter.py

@@ -0,0 +1,799 @@
+# -*- coding: utf-8 -*-
+"""
+
+    Custom docutils writer for plain text.
+    Based heavily on the Sphinx text writer.  See copyright below.
+
+    :copyright: Copyright 2007-2011 by the Sphinx team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+
+"""
+import os
+import re
+import textwrap
+
+from docutils import nodes, writers
+
+
+class TextWrapper(textwrap.TextWrapper):
+    """Custom subclass that uses a different word separator regex."""
+
+    wordsep_re = re.compile(
+        r'(\s+|'                                  # any whitespace
+        r'(?<=\s)(?::[a-z-]+:)?`\S+|'             # interpreted text start
+        r'[^\s\w]*\w+[a-zA-Z]-(?=\w+[a-zA-Z])|'   # hyphenated words
+        r'(?<=[\w\!\"\'\&\.\,\?])-{2,}(?=\w))')   # em-dash
+
+
+MAXWIDTH = 70
+STDINDENT = 3
+
+
+def my_wrap(text, width=MAXWIDTH, **kwargs):
+    w = TextWrapper(width=width, **kwargs)
+    return w.wrap(text)
+
+
+class TextWriter(writers.Writer):
+    supported = ('text',)
+    settings_spec = ('No options here.', '', ())
+    settings_defaults = {}
+
+    output = None
+
+    def __init__(self):
+        writers.Writer.__init__(self)
+
+    def translate(self):
+        visitor = TextTranslator(self.document)
+        self.document.walkabout(visitor)
+        self.output = visitor.body
+
+
+class TextTranslator(nodes.NodeVisitor):
+    sectionchars = '*=-~"+`'
+
+    def __init__(self, document):
+        nodes.NodeVisitor.__init__(self, document)
+
+        self.nl = os.linesep
+        self.states = [[]]
+        self.stateindent = [0]
+        self.list_counter = []
+        self.sectionlevel = 0
+        self.table = None
+
+    def add_text(self, text):
+        self.states[-1].append((-1, text))
+
+    def new_state(self, indent=STDINDENT):
+        self.states.append([])
+        self.stateindent.append(indent)
+
+    def end_state(self, wrap=True, end=[''], first=None):
+        content = self.states.pop()
+        maxindent = sum(self.stateindent)
+        indent = self.stateindent.pop()
+        result = []
+        toformat = []
+
+        def do_format():
+            if not toformat:
+                return
+            if wrap:
+                res = my_wrap(''.join(toformat), width=MAXWIDTH-maxindent)
+            else:
+                res = ''.join(toformat).splitlines()
+            if end:
+                res += end
+            result.append((indent, res))
+        for itemindent, item in content:
+            if itemindent == -1:
+                toformat.append(item)
+            else:
+                do_format()
+                result.append((indent + itemindent, item))
+                toformat = []
+        do_format()
+        if first is not None and result:
+            itemindent, item = result[0]
+            if item:
+                result.insert(0, (itemindent - indent, [first + item[0]]))
+                result[1] = (itemindent, item[1:])
+        self.states[-1].extend(result)
+
+    def visit_document(self, node):
+        self.new_state(0)
+
+    def depart_document(self, node):
+        self.end_state()
+        self.body = self.nl.join(line and (' '*indent + line)
+                                 for indent, lines in self.states[0]
+                                 for line in lines)
+        # XXX header/footer?
+
+    def visit_highlightlang(self, node):
+        raise nodes.SkipNode
+
+    def visit_section(self, node):
+        self._title_char = self.sectionchars[self.sectionlevel]
+        self.sectionlevel += 1
+
+    def depart_section(self, node):
+        self.sectionlevel -= 1
+
+    def visit_topic(self, node):
+        self.new_state(0)
+
+    def depart_topic(self, node):
+        self.end_state()
+
+    visit_sidebar = visit_topic
+    depart_sidebar = depart_topic
+
+    def visit_rubric(self, node):
+        self.new_state(0)
+        self.add_text('-[ ')
+
+    def depart_rubric(self, node):
+        self.add_text(' ]-')
+        self.end_state()
+
+    def visit_compound(self, node):
+        pass
+
+    def depart_compound(self, node):
+        pass
+
+    def visit_glossary(self, node):
+        pass
+
+    def depart_glossary(self, node):
+        pass
+
+    def visit_title(self, node):
+        if isinstance(node.parent, nodes.Admonition):
+            self.add_text(node.astext()+': ')
+            raise nodes.SkipNode
+        self.new_state(0)
+
+    def depart_title(self, node):
+        if isinstance(node.parent, nodes.section):
+            char = self._title_char
+        else:
+            char = '^'
+        text = ''.join(x[1] for x in self.states.pop() if x[0] == -1)
+        self.stateindent.pop()
+        self.states[-1].append((0, ['', text, '%s' % (char * len(text)), '']))
+
+    def visit_subtitle(self, node):
+        pass
+
+    def depart_subtitle(self, node):
+        pass
+
+    def visit_attribution(self, node):
+        self.add_text('-- ')
+
+    def depart_attribution(self, node):
+        pass
+
+    def visit_desc(self, node):
+        pass
+
+    def depart_desc(self, node):
+        pass
+
+    def visit_desc_signature(self, node):
+        self.new_state(0)
+        if node.parent['objtype'] in ('class', 'exception'):
+            self.add_text('%s ' % node.parent['objtype'])
+
+    def depart_desc_signature(self, node):
+        # XXX: wrap signatures in a way that makes sense
+        self.end_state(wrap=False, end=None)
+
+    def visit_desc_name(self, node):
+        pass
+
+    def depart_desc_name(self, node):
+        pass
+
+    def visit_desc_addname(self, node):
+        pass
+
+    def depart_desc_addname(self, node):
+        pass
+
+    def visit_desc_type(self, node):
+        pass
+
+    def depart_desc_type(self, node):
+        pass
+
+    def visit_desc_returns(self, node):
+        self.add_text(' -> ')
+
+    def depart_desc_returns(self, node):
+        pass
+
+    def visit_desc_parameterlist(self, node):
+        self.add_text('(')
+        self.first_param = 1
+
+    def depart_desc_parameterlist(self, node):
+        self.add_text(')')
+
+    def visit_desc_parameter(self, node):
+        if not self.first_param:
+            self.add_text(', ')
+        else:
+            self.first_param = 0
+        self.add_text(node.astext())
+        raise nodes.SkipNode
+
+    def visit_desc_optional(self, node):
+        self.add_text('[')
+
+    def depart_desc_optional(self, node):
+        self.add_text(']')
+
+    def visit_desc_annotation(self, node):
+        pass
+
+    def depart_desc_annotation(self, node):
+        pass
+
+    def visit_refcount(self, node):
+        pass
+
+    def depart_refcount(self, node):
+        pass
+
+    def visit_desc_content(self, node):
+        self.new_state()
+        self.add_text(self.nl)
+
+    def depart_desc_content(self, node):
+        self.end_state()
+
+    def visit_figure(self, node):
+        self.new_state()
+
+    def depart_figure(self, node):
+        self.end_state()
+
+    def visit_caption(self, node):
+        pass
+
+    def depart_caption(self, node):
+        pass
+
+    def visit_productionlist(self, node):
+        self.new_state()
+        names = []
+        for production in node:
+            names.append(production['tokenname'])
+        maxlen = max(len(name) for name in names)
+        for production in node:
+            if production['tokenname']:
+                self.add_text(production['tokenname'].ljust(maxlen) + ' ::=')
+                lastname = production['tokenname']
+            else:
+                self.add_text('%s    ' % (' '*len(lastname)))
+            self.add_text(production.astext() + self.nl)
+        self.end_state(wrap=False)
+        raise nodes.SkipNode
+
+    def visit_seealso(self, node):
+        self.new_state()
+
+    def depart_seealso(self, node):
+        self.end_state(first='')
+
+    def visit_footnote(self, node):
+        self._footnote = node.children[0].astext().strip()
+        self.new_state(len(self._footnote) + 3)
+
+    def depart_footnote(self, node):
+        self.end_state(first='[%s] ' % self._footnote)
+
+    def visit_citation(self, node):
+        if len(node) and isinstance(node[0], nodes.label):
+            self._citlabel = node[0].astext()
+        else:
+            self._citlabel = ''
+        self.new_state(len(self._citlabel) + 3)
+
+    def depart_citation(self, node):
+        self.end_state(first='[%s] ' % self._citlabel)
+
+    def visit_label(self, node):
+        raise nodes.SkipNode
+
+    # XXX: option list could use some better styling
+
+    def visit_option_list(self, node):
+        pass
+
+    def depart_option_list(self, node):
+        pass
+
+    def visit_option_list_item(self, node):
+        self.new_state(0)
+
+    def depart_option_list_item(self, node):
+        self.end_state()
+
+    def visit_option_group(self, node):
+        self._firstoption = True
+
+    def depart_option_group(self, node):
+        self.add_text('     ')
+
+    def visit_option(self, node):
+        if self._firstoption:
+            self._firstoption = False
+        else:
+            self.add_text(', ')
+
+    def depart_option(self, node):
+        pass
+
+    def visit_option_string(self, node):
+        pass
+
+    def depart_option_string(self, node):
+        pass
+
+    def visit_option_argument(self, node):
+        self.add_text(node['delimiter'])
+
+    def depart_option_argument(self, node):
+        pass
+
+    def visit_description(self, node):
+        pass
+
+    def depart_description(self, node):
+        pass
+
+    def visit_tabular_col_spec(self, node):
+        raise nodes.SkipNode
+
+    def visit_colspec(self, node):
+        self.table[0].append(node['colwidth'])
+        raise nodes.SkipNode
+
+    def visit_tgroup(self, node):
+        pass
+
+    def depart_tgroup(self, node):
+        pass
+
+    def visit_thead(self, node):
+        pass
+
+    def depart_thead(self, node):
+        pass
+
+    def visit_tbody(self, node):
+        self.table.append('sep')
+
+    def depart_tbody(self, node):
+        pass
+
+    def visit_row(self, node):
+        self.table.append([])
+
+    def depart_row(self, node):
+        pass
+
+    def visit_entry(self, node):
+        if 'morerows' in node or 'morecols' in node:
+            raise NotImplementedError('Column or row spanning cells are '
+                                      'not implemented.')
+        self.new_state(0)
+
+    def depart_entry(self, node):
+        text = self.nl.join(self.nl.join(x[1]) for x in self.states.pop())
+        self.stateindent.pop()
+        self.table[-1].append(text)
+
+    def visit_table(self, node):
+        if self.table:
+            raise NotImplementedError('Nested tables are not supported.')
+        self.new_state(0)
+        self.table = [[]]
+
+    def depart_table(self, node):
+        lines = self.table[1:]
+        fmted_rows = []
+        colwidths = self.table[0]
+        realwidths = colwidths[:]
+        separator = 0
+        # don't allow paragraphs in table cells for now
+        for line in lines:
+            if line == 'sep':
+                separator = len(fmted_rows)
+            else:
+                cells = []
+                for i, cell in enumerate(line):
+                    par = my_wrap(cell, width=colwidths[i])
+                    if par:
+                        maxwidth = max(map(len, par))
+                    else:
+                        maxwidth = 0
+                    realwidths[i] = max(realwidths[i], maxwidth)
+                    cells.append(par)
+                fmted_rows.append(cells)
+
+        def writesep(char='-'):
+            out = ['+']
+            for width in realwidths:
+                out.append(char * (width+2))
+                out.append('+')
+            self.add_text(''.join(out) + self.nl)
+
+        def writerow(row):
+            lines = zip(*row)
+            for line in lines:
+                out = ['|']
+                for i, cell in enumerate(line):
+                    if cell:
+                        out.append(' ' + cell.ljust(realwidths[i]+1))
+                    else:
+                        out.append(' ' * (realwidths[i] + 2))
+                    out.append('|')
+                self.add_text(''.join(out) + self.nl)
+
+        for i, row in enumerate(fmted_rows):
+            if separator and i == separator:
+                writesep('=')
+            else:
+                writesep('-')
+            writerow(row)
+        writesep('-')
+        self.table = None
+        self.end_state(wrap=False)
+
+    def visit_acks(self, node):
+        self.new_state(0)
+        self.add_text(
+            ', '.join(n.astext() for n in node.children[0].children) + '.')
+        self.end_state()
+        raise nodes.SkipNode
+
+    def visit_image(self, node):
+        if 'alt' in node.attributes:
+            self.add_text(_('[image: %s]') % node['alt'])
+        self.add_text(_('[image]'))
+        raise nodes.SkipNode
+
+    def visit_transition(self, node):
+        indent = sum(self.stateindent)
+        self.new_state(0)
+        self.add_text('=' * (MAXWIDTH - indent))
+        self.end_state()
+        raise nodes.SkipNode
+
+    def visit_bullet_list(self, node):
+        self.list_counter.append(-1)
+
+    def depart_bullet_list(self, node):
+        self.list_counter.pop()
+
+    def visit_enumerated_list(self, node):
+        self.list_counter.append(0)
+
+    def depart_enumerated_list(self, node):
+        self.list_counter.pop()
+
+    def visit_definition_list(self, node):
+        self.list_counter.append(-2)
+
+    def depart_definition_list(self, node):
+        self.list_counter.pop()
+
+    def visit_list_item(self, node):
+        if self.list_counter[-1] == -1:
+            # bullet list
+            self.new_state(2)
+        elif self.list_counter[-1] == -2:
+            # definition list
+            pass
+        else:
+            # enumerated list
+            self.list_counter[-1] += 1
+            self.new_state(len(str(self.list_counter[-1])) + 2)
+
+    def depart_list_item(self, node):
+        if self.list_counter[-1] == -1:
+            self.end_state(first='* ', end=None)
+        elif self.list_counter[-1] == -2:
+            pass
+        else:
+            self.end_state(first='%s. ' % self.list_counter[-1], end=None)
+
+    def visit_definition_list_item(self, node):
+        self._li_has_classifier = len(node) >= 2 and \
+                                  isinstance(node[1], nodes.classifier)
+
+    def depart_definition_list_item(self, node):
+        pass
+
+    def visit_term(self, node):
+        self.new_state(0)
+
+    def depart_term(self, node):
+        if not self._li_has_classifier:
+            self.end_state(end=None)
+
+    def visit_termsep(self, node):
+        self.add_text(', ')
+        raise nodes.SkipNode
+
+    def visit_classifier(self, node):
+        self.add_text(' : ')
+
+    def depart_classifier(self, node):
+        self.end_state(end=None)
+
+    def visit_definition(self, node):
+        self.new_state()
+
+    def depart_definition(self, node):
+        self.end_state()
+
+    def visit_field_list(self, node):
+        pass
+
+    def depart_field_list(self, node):
+        pass
+
+    def visit_field(self, node):
+        pass
+
+    def depart_field(self, node):
+        pass
+
+    def visit_field_name(self, node):
+        self.new_state(0)
+
+    def depart_field_name(self, node):
+        self.add_text(':')
+        self.end_state(end=None)
+
+    def visit_field_body(self, node):
+        self.new_state()
+
+    def depart_field_body(self, node):
+        self.end_state()
+
+    def visit_centered(self, node):
+        pass
+
+    def depart_centered(self, node):
+        pass
+
+    def visit_hlist(self, node):
+        pass
+
+    def depart_hlist(self, node):
+        pass
+
+    def visit_hlistcol(self, node):
+        pass
+
+    def depart_hlistcol(self, node):
+        pass
+
+    def visit_admonition(self, node):
+        self.new_state(0)
+
+    def depart_admonition(self, node):
+        self.end_state()
+
+    def visit_versionmodified(self, node):
+        self.new_state(0)
+
+    def depart_versionmodified(self, node):
+        self.end_state()
+
+    def visit_literal_block(self, node):
+        self.new_state()
+
+    def depart_literal_block(self, node):
+        self.end_state(wrap=False)
+
+    def visit_doctest_block(self, node):
+        self.new_state(0)
+
+    def depart_doctest_block(self, node):
+        self.end_state(wrap=False)
+
+    def visit_line_block(self, node):
+        self.new_state(0)
+
+    def depart_line_block(self, node):
+        self.end_state(wrap=False)
+
+    def visit_line(self, node):
+        pass
+
+    def depart_line(self, node):
+        pass
+
+    def visit_block_quote(self, node):
+        self.new_state()
+
+    def depart_block_quote(self, node):
+        self.end_state()
+
+    def visit_compact_paragraph(self, node):
+        pass
+
+    def depart_compact_paragraph(self, node):
+        pass
+
+    def visit_paragraph(self, node):
+        self.new_state(0)
+
+    def depart_paragraph(self, node):
+        self.end_state()
+
+    def visit_target(self, node):
+        raise nodes.SkipNode
+
+    def visit_index(self, node):
+        raise nodes.SkipNode
+
+    def visit_substitution_definition(self, node):
+        raise nodes.SkipNode
+
+    def visit_pending_xref(self, node):
+        pass
+
+    def depart_pending_xref(self, node):
+        pass
+
+    def visit_reference(self, node):
+        pass
+
+    def depart_reference(self, node):
+        pass
+
+    def visit_download_reference(self, node):
+        pass
+
+    def depart_download_reference(self, node):
+        pass
+
+    def visit_emphasis(self, node):
+        self.add_text('*')
+
+    def depart_emphasis(self, node):
+        self.add_text('*')
+
+    def visit_literal_emphasis(self, node):
+        self.add_text('*')
+
+    def depart_literal_emphasis(self, node):
+        self.add_text('*')
+
+    def visit_strong(self, node):
+        self.add_text('**')
+
+    def depart_strong(self, node):
+        self.add_text('**')
+
+    def visit_abbreviation(self, node):
+        self.add_text('')
+
+    def depart_abbreviation(self, node):
+        if node.hasattr('explanation'):
+            self.add_text(' (%s)' % node['explanation'])
+
+    def visit_title_reference(self, node):
+        self.add_text('*')
+
+    def depart_title_reference(self, node):
+        self.add_text('*')
+
+    def visit_literal(self, node):
+        self.add_text('"')
+
+    def depart_literal(self, node):
+        self.add_text('"')
+
+    def visit_subscript(self, node):
+        self.add_text('_')
+
+    def depart_subscript(self, node):
+        pass
+
+    def visit_superscript(self, node):
+        self.add_text('^')
+
+    def depart_superscript(self, node):
+        pass
+
+    def visit_footnote_reference(self, node):
+        self.add_text('[%s]' % node.astext())
+        raise nodes.SkipNode
+
+    def visit_citation_reference(self, node):
+        self.add_text('[%s]' % node.astext())
+        raise nodes.SkipNode
+
+    def visit_Text(self, node):
+        self.add_text(node.astext())
+
+    def depart_Text(self, node):
+        pass
+
+    def visit_generated(self, node):
+        pass
+
+    def depart_generated(self, node):
+        pass
+
+    def visit_inline(self, node):
+        pass
+
+    def depart_inline(self, node):
+        pass
+
+    def visit_problematic(self, node):
+        self.add_text('>>')
+
+    def depart_problematic(self, node):
+        self.add_text('<<')
+
+    def visit_system_message(self, node):
+        self.new_state(0)
+        self.add_text('<SYSTEM MESSAGE: %s>' % node.astext())
+        self.end_state()
+        raise nodes.SkipNode
+
+    def visit_comment(self, node):
+        raise nodes.SkipNode
+
+    def visit_meta(self, node):
+        # only valid for HTML
+        raise nodes.SkipNode
+
+    def visit_raw(self, node):
+        if 'text' in node.get('format', '').split():
+            self.body.append(node.astext())
+        raise nodes.SkipNode
+
+    def _visit_admonition(self, node):
+        self.new_state(2)
+
+    def _make_depart_admonition(name):
+        def depart_admonition(self, node):
+            self.end_state(first=name.capitalize() + ': ')
+        return depart_admonition
+
+    visit_attention = _visit_admonition
+    depart_attention = _make_depart_admonition('attention')
+    visit_caution = _visit_admonition
+    depart_caution = _make_depart_admonition('caution')
+    visit_danger = _visit_admonition
+    depart_danger = _make_depart_admonition('danger')
+    visit_error = _visit_admonition
+    depart_error = _make_depart_admonition('error')
+    visit_hint = _visit_admonition
+    depart_hint = _make_depart_admonition('hint')
+    visit_important = _visit_admonition
+    depart_important = _make_depart_admonition('important')
+    visit_note = _visit_admonition
+    depart_note = _make_depart_admonition('note')
+    visit_tip = _visit_admonition
+    depart_tip = _make_depart_admonition('tip')
+    visit_warning = _visit_admonition
+    depart_warning = _make_depart_admonition('warning')
+
+    def unknown_visit(self, node):
+        raise NotImplementedError('Unknown node: ' + node.__class__.__name__)

data/lib/python3.10/site-packages/awscli/customizations/cloudformation/__init__.py

@@ -0,0 +1,31 @@
+# Copyright 2012-2015 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+# http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+from awscli.customizations.cloudformation.package import PackageCommand
+from awscli.customizations.cloudformation.deploy import DeployCommand
+
+
+def initialize(cli):
+    """
+    The entry point for CloudFormation high level commands.
+    """
+    cli.register('building-command-table.cloudformation', inject_commands)
+
+
+def inject_commands(command_table, session, **kwargs):
+    """
+    Called when the CloudFormation command table is being built. Used to
+    inject new high level commands into the command list. These high level
+    commands must not collide with existing low-level API call names.
+    """
+    command_table['package'] = PackageCommand(session)
+    command_table['deploy'] = DeployCommand(session)

data/lib/python3.10/site-packages/awscli/customizations/cloudformation/artifact_exporter.py

@@ -0,0 +1,683 @@
+# Copyright 2012-2015 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+# http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+import logging
+import os
+import tempfile
+import zipfile
+import contextlib
+import uuid
+import shutil
+from botocore.utils import set_value_from_jmespath
+
+from awscli.compat import urlparse
+from contextlib import contextmanager
+from awscli.customizations.cloudformation import exceptions
+from awscli.customizations.cloudformation.yamlhelper import yaml_dump, \
+    yaml_parse
+import jmespath
+
+
+LOG = logging.getLogger(__name__)
+
+
+def is_path_value_valid(path):
+    return isinstance(path, str)
+
+
+def make_abs_path(directory, path):
+    if is_path_value_valid(path) and not os.path.isabs(path):
+        return os.path.normpath(os.path.join(directory, path))
+    else:
+        return path
+
+
+def is_s3_url(url):
+    try:
+        parse_s3_url(url)
+        return True
+    except ValueError:
+        return False
+
+
+def is_local_folder(path):
+    return is_path_value_valid(path) and os.path.isdir(path)
+
+
+def is_local_file(path):
+    return is_path_value_valid(path) and os.path.isfile(path)
+
+
+def is_zip_file(path):
+    return (
+        is_path_value_valid(path) and
+        zipfile.is_zipfile(path))
+
+
+def parse_s3_url(url,
+                 bucket_name_property="Bucket",
+                 object_key_property="Key",
+                 version_property=None):
+
+    if isinstance(url, str) \
+            and url.startswith("s3://"):
+
+        # Python < 2.7.10 don't parse query parameters from URI with custom
+        # scheme such as s3://blah/blah. As a workaround, remove scheme
+        # altogether to trigger the parser "s3://foo/bar?v=1" =>"//foo/bar?v=1"
+        parsed = urlparse.urlparse(url[3:])
+        query = urlparse.parse_qs(parsed.query)
+
+        if parsed.netloc and parsed.path:
+            result = dict()
+            result[bucket_name_property] = parsed.netloc
+            result[object_key_property] = parsed.path.lstrip('/')
+
+            # If there is a query string that has a single versionId field,
+            # set the object version and return
+            if version_property is not None \
+                    and 'versionId' in query \
+                    and len(query['versionId']) == 1:
+                result[version_property] = query['versionId'][0]
+
+            return result
+
+    raise ValueError("URL given to the parse method is not a valid S3 url "
+                     "{0}".format(url))
+
+
+def upload_local_artifacts(resource_id, resource_dict, property_name,
+                           parent_dir, uploader):
+    """
+    Upload local artifacts referenced by the property at given resource and
+    return S3 URL of the uploaded object. It is the responsibility of callers
+    to ensure property value is a valid string
+
+    If path refers to a file, this method will upload the file. If path refers
+    to a folder, this method will zip the folder and upload the zip to S3.
+    If path is omitted, this method will zip the current working folder and
+    upload.
+
+    If path is already a path to S3 object, this method does nothing.
+
+    :param resource_id:     Id of the CloudFormation resource
+    :param resource_dict:   Dictionary containing resource definition
+    :param property_name:   Property name of CloudFormation resource where this
+                            local path is present
+    :param parent_dir:      Resolve all relative paths with respect to this
+                            directory
+    :param uploader:        Method to upload files to S3
+
+    :return:                S3 URL of the uploaded object
+    :raise:                 ValueError if path is not a S3 URL or a local path
+    """
+
+    local_path = jmespath.search(property_name, resource_dict)
+
+    if local_path is None:
+        # Build the root directory and upload to S3
+        local_path = parent_dir
+
+    if is_s3_url(local_path):
+        # A valid CloudFormation template will specify artifacts as S3 URLs.
+        # This check is supporting the case where your resource does not
+        # refer to local artifacts
+        # Nothing to do if property value is an S3 URL
+        LOG.debug("Property {0} of {1} is already a S3 URL"
+                  .format(property_name, resource_id))
+        return local_path
+
+    local_path = make_abs_path(parent_dir, local_path)
+
+    # Or, pointing to a folder. Zip the folder and upload
+    if is_local_folder(local_path):
+        return zip_and_upload(local_path, uploader)
+
+    # Path could be pointing to a file. Upload the file
+    elif is_local_file(local_path):
+        return uploader.upload_with_dedup(local_path)
+
+    raise exceptions.InvalidLocalPathError(
+            resource_id=resource_id,
+            property_name=property_name,
+            local_path=local_path)
+
+
+def zip_and_upload(local_path, uploader):
+    with zip_folder(local_path) as zipfile:
+            return uploader.upload_with_dedup(zipfile)
+
+
+@contextmanager
+def zip_folder(folder_path):
+    """
+    Zip the entire folder and return a file to the zip. Use this inside
+    a "with" statement to cleanup the zipfile after it is used.
+
+    :param folder_path:
+    :return: Name of the zipfile
+    """
+
+    filename = os.path.join(
+        tempfile.gettempdir(), "data-" + uuid.uuid4().hex)
+
+    zipfile_name = make_zip(filename, folder_path)
+    try:
+        yield zipfile_name
+    finally:
+        if os.path.exists(zipfile_name):
+            os.remove(zipfile_name)
+
+
+def make_zip(filename, source_root):
+    zipfile_name = "{0}.zip".format(filename)
+    source_root = os.path.abspath(source_root)
+    with open(zipfile_name, 'wb') as f:
+        zip_file = zipfile.ZipFile(f, 'w', zipfile.ZIP_DEFLATED)
+        with contextlib.closing(zip_file) as zf:
+            for root, dirs, files in os.walk(source_root, followlinks=True):
+                for filename in files:
+                    full_path = os.path.join(root, filename)
+                    relative_path = os.path.relpath(
+                        full_path, source_root)
+                    zf.write(full_path, relative_path)
+
+    return zipfile_name
+
+
+@contextmanager
+def mktempfile():
+    directory = tempfile.gettempdir()
+    filename = os.path.join(directory, uuid.uuid4().hex)
+
+    try:
+        with open(filename, "w+") as handle:
+            yield handle
+    finally:
+        if os.path.exists(filename):
+            os.remove(filename)
+
+
+def copy_to_temp_dir(filepath):
+    tmp_dir = tempfile.mkdtemp()
+    dst = os.path.join(tmp_dir, os.path.basename(filepath))
+    shutil.copy(filepath, dst)
+    return tmp_dir
+
+
+class Resource(object):
+    """
+    Base class representing a CloudFormation resource that can be exported
+    """
+
+    RESOURCE_TYPE = None
+    PROPERTY_NAME = None
+    PACKAGE_NULL_PROPERTY = True
+    # Set this property to True in base class if you want the exporter to zip
+    # up the file before uploading This is useful for Lambda functions.
+    FORCE_ZIP = False
+
+    def __init__(self, uploader):
+        self.uploader = uploader
+
+    def export(self, resource_id, resource_dict, parent_dir):
+        if resource_dict is None:
+            return
+
+        property_value = jmespath.search(self.PROPERTY_NAME, resource_dict)
+
+        if not property_value and not self.PACKAGE_NULL_PROPERTY:
+            return
+
+        if isinstance(property_value, dict):
+            LOG.debug("Property {0} of {1} resource is not a URL"
+                      .format(self.PROPERTY_NAME, resource_id))
+            return
+
+        # If property is a file but not a zip file, place file in temp
+        # folder and send the temp folder to be zipped
+        temp_dir = None
+        if is_local_file(property_value) and not \
+                is_zip_file(property_value) and self.FORCE_ZIP:
+            temp_dir = copy_to_temp_dir(property_value)
+            set_value_from_jmespath(resource_dict, self.PROPERTY_NAME, temp_dir)
+
+        try:
+            self.do_export(resource_id, resource_dict, parent_dir)
+
+        except Exception as ex:
+            LOG.debug("Unable to export", exc_info=ex)
+            raise exceptions.ExportFailedError(
+                    resource_id=resource_id,
+                    property_name=self.PROPERTY_NAME,
+                    property_value=property_value,
+                    ex=ex)
+        finally:
+            if temp_dir:
+                shutil.rmtree(temp_dir)
+
+    def do_export(self, resource_id, resource_dict, parent_dir):
+        """
+        Default export action is to upload artifacts and set the property to
+        S3 URL of the uploaded object
+        """
+        uploaded_url = upload_local_artifacts(resource_id, resource_dict,
+                                   self.PROPERTY_NAME,
+                                   parent_dir, self.uploader)
+        set_value_from_jmespath(resource_dict, self.PROPERTY_NAME, uploaded_url)
+
+
+class ResourceWithS3UrlDict(Resource):
+    """
+    Represents CloudFormation resources that need the S3 URL to be specified as
+    an dict like {Bucket: "", Key: "", Version: ""}
+    """
+
+    BUCKET_NAME_PROPERTY = None
+    OBJECT_KEY_PROPERTY = None
+    VERSION_PROPERTY = None
+
+    def __init__(self, uploader):
+        super(ResourceWithS3UrlDict, self).__init__(uploader)
+
+    def do_export(self, resource_id, resource_dict, parent_dir):
+        """
+        Upload to S3 and set property to an dict representing the S3 url
+        of the uploaded object
+        """
+
+        artifact_s3_url = \
+            upload_local_artifacts(resource_id, resource_dict,
+                                   self.PROPERTY_NAME,
+                                   parent_dir, self.uploader)
+
+        parsed_url = parse_s3_url(
+                artifact_s3_url,
+                bucket_name_property=self.BUCKET_NAME_PROPERTY,
+                object_key_property=self.OBJECT_KEY_PROPERTY,
+                version_property=self.VERSION_PROPERTY)
+        set_value_from_jmespath(resource_dict, self.PROPERTY_NAME, parsed_url)
+
+
+class ServerlessFunctionResource(Resource):
+    RESOURCE_TYPE = "AWS::Serverless::Function"
+    PROPERTY_NAME = "CodeUri"
+    FORCE_ZIP = True
+
+
+class ServerlessApiResource(Resource):
+    RESOURCE_TYPE = "AWS::Serverless::Api"
+    PROPERTY_NAME = "DefinitionUri"
+    # Don't package the directory if DefinitionUri is omitted.
+    # Necessary to support DefinitionBody
+    PACKAGE_NULL_PROPERTY = False
+
+
+class GraphQLSchemaResource(Resource):
+    RESOURCE_TYPE = "AWS::AppSync::GraphQLSchema"
+    PROPERTY_NAME = "DefinitionS3Location"
+    # Don't package the directory if DefinitionS3Location is omitted.
+    # Necessary to support Definition
+    PACKAGE_NULL_PROPERTY = False
+
+
+class AppSyncResolverRequestTemplateResource(Resource):
+    RESOURCE_TYPE = "AWS::AppSync::Resolver"
+    PROPERTY_NAME = "RequestMappingTemplateS3Location"
+    # Don't package the directory if RequestMappingTemplateS3Location is omitted.
+    # Necessary to support RequestMappingTemplate
+    PACKAGE_NULL_PROPERTY = False
+
+
+class AppSyncResolverResponseTemplateResource(Resource):
+    RESOURCE_TYPE = "AWS::AppSync::Resolver"
+    PROPERTY_NAME = "ResponseMappingTemplateS3Location"
+    # Don't package the directory if ResponseMappingTemplateS3Location is omitted.
+    # Necessary to support ResponseMappingTemplate
+    PACKAGE_NULL_PROPERTY = False
+
+
+class AppSyncFunctionConfigurationRequestTemplateResource(Resource):
+    RESOURCE_TYPE = "AWS::AppSync::FunctionConfiguration"
+    PROPERTY_NAME = "RequestMappingTemplateS3Location"
+    # Don't package the directory if RequestMappingTemplateS3Location is omitted.
+    # Necessary to support RequestMappingTemplate
+    PACKAGE_NULL_PROPERTY = False
+
+
+class AppSyncFunctionConfigurationResponseTemplateResource(Resource):
+    RESOURCE_TYPE = "AWS::AppSync::FunctionConfiguration"
+    PROPERTY_NAME = "ResponseMappingTemplateS3Location"
+    # Don't package the directory if ResponseMappingTemplateS3Location is omitted.
+    # Necessary to support ResponseMappingTemplate
+    PACKAGE_NULL_PROPERTY = False
+
+
+class LambdaFunctionResource(ResourceWithS3UrlDict):
+    RESOURCE_TYPE = "AWS::Lambda::Function"
+    PROPERTY_NAME = "Code"
+    BUCKET_NAME_PROPERTY = "S3Bucket"
+    OBJECT_KEY_PROPERTY = "S3Key"
+    VERSION_PROPERTY = "S3ObjectVersion"
+    FORCE_ZIP = True
+
+
+class ApiGatewayRestApiResource(ResourceWithS3UrlDict):
+    RESOURCE_TYPE = "AWS::ApiGateway::RestApi"
+    PROPERTY_NAME = "BodyS3Location"
+    PACKAGE_NULL_PROPERTY = False
+    BUCKET_NAME_PROPERTY = "Bucket"
+    OBJECT_KEY_PROPERTY = "Key"
+    VERSION_PROPERTY = "Version"
+
+
+class ElasticBeanstalkApplicationVersion(ResourceWithS3UrlDict):
+    RESOURCE_TYPE = "AWS::ElasticBeanstalk::ApplicationVersion"
+    PROPERTY_NAME = "SourceBundle"
+    BUCKET_NAME_PROPERTY = "S3Bucket"
+    OBJECT_KEY_PROPERTY = "S3Key"
+    VERSION_PROPERTY = None
+
+
+class LambdaLayerVersionResource(ResourceWithS3UrlDict):
+    RESOURCE_TYPE = "AWS::Lambda::LayerVersion"
+    PROPERTY_NAME = "Content"
+    BUCKET_NAME_PROPERTY = "S3Bucket"
+    OBJECT_KEY_PROPERTY = "S3Key"
+    VERSION_PROPERTY = "S3ObjectVersion"
+    FORCE_ZIP = True
+
+
+class ServerlessLayerVersionResource(Resource):
+    RESOURCE_TYPE = "AWS::Serverless::LayerVersion"
+    PROPERTY_NAME = "ContentUri"
+    FORCE_ZIP = True
+
+
+class ServerlessRepoApplicationReadme(Resource):
+    RESOURCE_TYPE = "AWS::ServerlessRepo::Application"
+    PROPERTY_NAME = "ReadmeUrl"
+    PACKAGE_NULL_PROPERTY = False
+
+
+class ServerlessRepoApplicationLicense(Resource):
+    RESOURCE_TYPE = "AWS::ServerlessRepo::Application"
+    PROPERTY_NAME = "LicenseUrl"
+    PACKAGE_NULL_PROPERTY = False
+
+
+class StepFunctionsStateMachineDefinitionResource(ResourceWithS3UrlDict):
+    RESOURCE_TYPE = "AWS::StepFunctions::StateMachine"
+    PROPERTY_NAME = "DefinitionS3Location"
+    BUCKET_NAME_PROPERTY = "Bucket"
+    OBJECT_KEY_PROPERTY = "Key"
+    VERSION_PROPERTY = "Version"
+    PACKAGE_NULL_PROPERTY = False
+
+
+class ServerlessStateMachineDefinitionResource(ResourceWithS3UrlDict):
+    RESOURCE_TYPE = "AWS::Serverless::StateMachine"
+    PROPERTY_NAME = "DefinitionUri"
+    BUCKET_NAME_PROPERTY = "Bucket"
+    OBJECT_KEY_PROPERTY = "Key"
+    VERSION_PROPERTY = "Version"
+    PACKAGE_NULL_PROPERTY = False
+
+
+class CloudFormationStackResource(Resource):
+    """
+    Represents CloudFormation::Stack resource that can refer to a nested
+    stack template via TemplateURL property.
+    """
+    RESOURCE_TYPE = "AWS::CloudFormation::Stack"
+    PROPERTY_NAME = "TemplateURL"
+
+    def __init__(self, uploader):
+        super(CloudFormationStackResource, self).__init__(uploader)
+
+    def do_export(self, resource_id, resource_dict, parent_dir):
+        """
+        If the nested stack template is valid, this method will
+        export on the nested template, upload the exported template to S3
+        and set property to URL of the uploaded S3 template
+        """
+
+        template_path = resource_dict.get(self.PROPERTY_NAME, None)
+
+        if template_path is None or is_s3_url(template_path) or \
+                template_path.startswith("http://") or \
+                template_path.startswith("https://"):
+            # Nothing to do
+            return
+
+        abs_template_path = make_abs_path(parent_dir, template_path)
+        if not is_local_file(abs_template_path):
+            raise exceptions.InvalidTemplateUrlParameterError(
+                    property_name=self.PROPERTY_NAME,
+                    resource_id=resource_id,
+                    template_path=abs_template_path)
+
+        exported_template_dict = \
+            Template(template_path, parent_dir, self.uploader).export()
+
+        exported_template_str = yaml_dump(exported_template_dict)
+
+        with mktempfile() as temporary_file:
+            temporary_file.write(exported_template_str)
+            temporary_file.flush()
+
+            url = self.uploader.upload_with_dedup(
+                    temporary_file.name, "template")
+
+            # TemplateUrl property requires S3 URL to be in path-style format
+            parts = parse_s3_url(url, version_property="Version")
+            s3_path_url = self.uploader.to_path_style_s3_url(
+                    parts["Key"], parts.get("Version", None))
+            set_value_from_jmespath(resource_dict, self.PROPERTY_NAME, s3_path_url)
+
+
+class ServerlessApplicationResource(CloudFormationStackResource):
+    """
+    Represents Serverless::Application resource that can refer to a nested
+    app template via Location property.
+    """
+    RESOURCE_TYPE = "AWS::Serverless::Application"
+    PROPERTY_NAME = "Location"
+
+
+
+class GlueJobCommandScriptLocationResource(Resource):
+    """
+    Represents Glue::Job resource.
+    """
+    RESOURCE_TYPE = "AWS::Glue::Job"
+    # Note the PROPERTY_NAME includes a '.' implying it's nested.
+    PROPERTY_NAME = "Command.ScriptLocation"
+
+
+class CodeCommitRepositoryS3Resource(ResourceWithS3UrlDict):
+    """
+    Represents CodeCommit::Repository resource.
+    """
+    RESOURCE_TYPE = "AWS::CodeCommit::Repository"
+    PROPERTY_NAME = "Code.S3"
+    BUCKET_NAME_PROPERTY = "Bucket"
+    OBJECT_KEY_PROPERTY = "Key"
+    VERSION_PROPERTY = "ObjectVersion"
+    # Don't package the directory if S3 is omitted.
+    PACKAGE_NULL_PROPERTY = False
+    FORCE_ZIP = True
+
+
+RESOURCES_EXPORT_LIST = [
+    ServerlessFunctionResource,
+    ServerlessApiResource,
+    GraphQLSchemaResource,
+    AppSyncResolverRequestTemplateResource,
+    AppSyncResolverResponseTemplateResource,
+    AppSyncFunctionConfigurationRequestTemplateResource,
+    AppSyncFunctionConfigurationResponseTemplateResource,
+    ApiGatewayRestApiResource,
+    LambdaFunctionResource,
+    ElasticBeanstalkApplicationVersion,
+    CloudFormationStackResource,
+    ServerlessApplicationResource,
+    ServerlessLayerVersionResource,
+    LambdaLayerVersionResource,
+    GlueJobCommandScriptLocationResource,
+    StepFunctionsStateMachineDefinitionResource,
+    ServerlessStateMachineDefinitionResource,
+    CodeCommitRepositoryS3Resource
+]
+
+METADATA_EXPORT_LIST = [
+    ServerlessRepoApplicationReadme,
+    ServerlessRepoApplicationLicense
+]
+
+
+def include_transform_export_handler(template_dict, uploader, parent_dir):
+    if template_dict.get("Name", None) != "AWS::Include":
+        return template_dict
+
+    include_location = template_dict.get("Parameters", {}).get("Location", None)
+    if not include_location \
+            or not is_path_value_valid(include_location) \
+            or is_s3_url(include_location):
+        # `include_location` is either empty, or not a string, or an S3 URI
+        return template_dict
+
+    # We are confident at this point that `include_location` is a string containing the local path
+    abs_include_location = os.path.join(parent_dir, include_location)
+    if is_local_file(abs_include_location):
+        template_dict["Parameters"]["Location"] = uploader.upload_with_dedup(abs_include_location)
+    else:
+        raise exceptions.InvalidLocalPathError(
+            resource_id="AWS::Include",
+            property_name="Location",
+            local_path=abs_include_location)
+
+    return template_dict
+
+
+GLOBAL_EXPORT_DICT = {
+    "Fn::Transform": include_transform_export_handler
+}
+
+
+class Template(object):
+    """
+    Class to export a CloudFormation template
+    """
+
+    def __init__(self, template_path, parent_dir, uploader,
+                 resources_to_export=RESOURCES_EXPORT_LIST,
+                 metadata_to_export=METADATA_EXPORT_LIST):
+        """
+        Reads the template and makes it ready for export
+        """
+
+        if not (is_local_folder(parent_dir) and os.path.isabs(parent_dir)):
+            raise ValueError("parent_dir parameter must be "
+                             "an absolute path to a folder {0}"
+                             .format(parent_dir))
+
+        abs_template_path = make_abs_path(parent_dir, template_path)
+        template_dir = os.path.dirname(abs_template_path)
+
+        with open(abs_template_path, "r") as handle:
+            template_str = handle.read()
+
+        self.template_dict = yaml_parse(template_str)
+        self.template_dir = template_dir
+        self.resources_to_export = resources_to_export
+        self.metadata_to_export = metadata_to_export
+        self.uploader = uploader
+
+    def export_global_artifacts(self, template_dict):
+        """
+        Template params such as AWS::Include transforms are not specific to
+        any resource type but contain artifacts that should be exported,
+        here we iterate through the template dict and export params with a
+        handler defined in GLOBAL_EXPORT_DICT
+        """
+        for key, val in template_dict.items():
+            if key in GLOBAL_EXPORT_DICT:
+                template_dict[key] = GLOBAL_EXPORT_DICT[key](val, self.uploader, self.template_dir)
+            elif isinstance(val, dict):
+                self.export_global_artifacts(val)
+            elif isinstance(val, list):
+                for item in val:
+                    if isinstance(item, dict):
+                        self.export_global_artifacts(item)
+        return template_dict
+
+    def export_metadata(self, template_dict):
+        """
+        Exports the local artifacts referenced by the metadata section in
+        the given template to an s3 bucket.
+
+        :return: The template with references to artifacts that have been
+        exported to s3.
+        """
+        if "Metadata" not in template_dict:
+            return template_dict
+
+        for metadata_type, metadata_dict in template_dict["Metadata"].items():
+            for exporter_class in self.metadata_to_export:
+                if exporter_class.RESOURCE_TYPE != metadata_type:
+                    continue
+
+                exporter = exporter_class(self.uploader)
+                exporter.export(metadata_type, metadata_dict, self.template_dir)
+
+        return template_dict
+
+    def export(self):
+        """
+        Exports the local artifacts referenced by the given template to an
+        s3 bucket.
+
+        :return: The template with references to artifacts that have been
+        exported to s3.
+        """
+        self.template_dict = self.export_metadata(self.template_dict)
+
+        if "Resources" not in self.template_dict:
+            return self.template_dict
+
+        self.template_dict = self.export_global_artifacts(self.template_dict)
+
+        self.export_resources(self.template_dict["Resources"])
+
+        return self.template_dict
+
+    def export_resources(self, resource_dict):
+        for resource_id, resource in resource_dict.items():
+
+            if resource_id.startswith("Fn::ForEach::"):
+                if not isinstance(resource, list) or len(resource) != 3:
+                    raise exceptions.InvalidForEachIntrinsicFunctionError(resource_id=resource_id)
+                self.export_resources(resource[2])
+                continue
+
+            resource_type = resource.get("Type", None)
+            resource_dict = resource.get("Properties", None)
+
+            for exporter_class in self.resources_to_export:
+                if exporter_class.RESOURCE_TYPE != resource_type:
+                    continue
+
+                # Export code resources
+                exporter = exporter_class(self.uploader)
+                exporter.export(resource_id, resource_dict, self.template_dir)

data/lib/python3.10/site-packages/awscli/customizations/cloudformation/deploy.py

@@ -0,0 +1,416 @@
+# Copyright 2015 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+# http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+import os
+import sys
+import logging
+
+from botocore.client import Config
+
+from awscli.customizations.cloudformation import exceptions
+from awscli.customizations.cloudformation.deployer import Deployer
+from awscli.customizations.s3uploader import S3Uploader
+from awscli.customizations.cloudformation.yamlhelper import yaml_parse
+
+from awscli.customizations.commands import BasicCommand
+from awscli.compat import get_stdout_text_writer
+from awscli.utils import write_exception
+
+LOG = logging.getLogger(__name__)
+
+
+class DeployCommand(BasicCommand):
+
+    MSG_NO_EXECUTE_CHANGESET = \
+        ("Changeset created successfully. Run the following command to "
+         "review changes:"
+         "\n"
+         "aws cloudformation describe-change-set --change-set-name "
+         "{changeset_id}"
+         "\n")
+
+    MSG_EXECUTE_SUCCESS = "Successfully created/updated stack - {stack_name}\n"
+
+    PARAMETER_OVERRIDE_CMD = "parameter-overrides"
+    TAGS_CMD = "tags"
+
+    NAME = 'deploy'
+    DESCRIPTION = BasicCommand.FROM_FILE("cloudformation",
+                                         "_deploy_description.rst")
+
+    ARG_TABLE = [
+        {
+            'name': 'template-file',
+            'required': True,
+            'help_text': (
+                'The path where your AWS CloudFormation'
+                ' template is located.'
+            )
+        },
+        {
+            'name': 'stack-name',
+            'action': 'store',
+            'required': True,
+            'help_text': (
+                'The name of the AWS CloudFormation stack you\'re deploying to.'
+                ' If you specify an existing stack, the command updates the'
+                ' stack. If you specify a new stack, the command creates it.'
+            )
+        },
+        {
+            'name': 's3-bucket',
+            'required': False,
+            'help_text': (
+                'The name of the S3 bucket where this command uploads your '
+                'CloudFormation template. This is required the deployments of '
+                'templates sized greater than 51,200 bytes'
+            )
+        },
+        {
+            "name": "force-upload",
+            "action": "store_true",
+            "help_text": (
+                'Indicates whether to override existing files in the S3 bucket.'
+                ' Specify this flag to upload artifacts even if they '
+                ' match existing artifacts in the S3 bucket.'
+            )
+        },
+        {
+            'name': 's3-prefix',
+            'help_text': (
+                'A prefix name that the command adds to the'
+                ' artifacts\' name when it uploads them to the S3 bucket.'
+                ' The prefix name is a path name (folder name) for'
+                ' the S3 bucket.'
+            )
+        },
+
+        {
+            'name': 'kms-key-id',
+            'help_text': (
+                'The ID of an AWS KMS key that the command uses'
+                ' to encrypt artifacts that are at rest in the S3 bucket.'
+            )
+        },
+        {
+            'name': PARAMETER_OVERRIDE_CMD,
+            'action': 'store',
+            'required': False,
+            'schema': {
+                'type': 'array',
+                'items': {
+                    'type': 'string'
+                }
+            },
+            'default': [],
+            'help_text': (
+                'A list of parameter structures that specify input parameters'
+                ' for your stack template. If you\'re updating a stack and you'
+                ' don\'t specify a parameter, the command uses the stack\'s'
+                ' existing value. For new stacks, you must specify'
+                ' parameters that don\'t have a default value.'
+                ' Syntax: ParameterKey1=ParameterValue1'
+                ' ParameterKey2=ParameterValue2 ...'
+            )
+        },
+        {
+            'name': 'capabilities',
+            'action': 'store',
+            'required': False,
+            'schema': {
+                'type': 'array',
+                'items': {
+                    'type': 'string',
+                    'enum': [
+                        'CAPABILITY_IAM',
+                        'CAPABILITY_NAMED_IAM'
+                    ]
+                }
+            },
+            'default': [],
+            'help_text': (
+                'A list of capabilities that you must specify before AWS'
+                ' Cloudformation can create certain stacks. Some stack'
+                ' templates might include resources that can affect'
+                ' permissions in your AWS account, for example, by creating'
+                ' new AWS Identity and Access Management (IAM) users. For'
+                ' those stacks, you must explicitly acknowledge their'
+                ' capabilities by specifying this parameter. '
+                ' The only valid values are CAPABILITY_IAM and'
+                ' CAPABILITY_NAMED_IAM. If you have IAM resources, you can'
+                ' specify either capability. If you have IAM resources with'
+                ' custom names, you must specify CAPABILITY_NAMED_IAM. If you'
+                ' don\'t specify this parameter, this action returns an'
+                ' InsufficientCapabilities error.'
+            )
+
+        },
+        {
+            'name': 'no-execute-changeset',
+            'action': 'store_false',
+            'dest': 'execute_changeset',
+            'required': False,
+            'help_text': (
+                'Indicates whether to execute the change set. Specify this'
+                ' flag if you want to view your stack changes before'
+                ' executing the change set. The command creates an'
+                ' AWS CloudFormation change set and then exits without'
+                ' executing the change set. After you view the change set,'
+                ' execute it to implement your changes.'
+            )
+        },
+        {
+            'name': 'disable-rollback',
+            'required': False,
+            'action': 'store_true',
+            'group_name': 'disable-rollback',
+            'dest': 'disable_rollback',
+            'default': False,
+            'help_text': (
+                'Preserve the state of previously provisioned resources when '
+                'the execute-change-set operation fails.'
+            )
+        },
+        {
+            'name': 'no-disable-rollback',
+            'required': False,
+            'action': 'store_false',
+            'group_name': 'disable-rollback',
+            'dest': 'disable_rollback',
+            'default': True,
+            'help_text': (
+                'Roll back all resource changes when the execute-change-set '
+                'operation fails.'
+            )
+        },
+        {
+            'name': 'role-arn',
+            'required': False,
+            'help_text': (
+                'The Amazon Resource Name (ARN) of an AWS Identity and Access '
+                'Management (IAM) role that AWS CloudFormation assumes when '
+                'executing the change set.'
+            )
+        },
+        {
+            'name': 'notification-arns',
+            'required': False,
+            'schema': {
+                'type': 'array',
+                'items': {
+                    'type': 'string'
+                }
+            },
+            'help_text': (
+                'Amazon Simple Notification Service topic Amazon Resource Names'
+                ' (ARNs) that AWS CloudFormation associates with the stack.'
+            )
+        },
+        {
+            'name': 'fail-on-empty-changeset',
+            'required': False,
+            'action': 'store_true',
+            'group_name': 'fail-on-empty-changeset',
+            'dest': 'fail_on_empty_changeset',
+            'default': True,
+            'help_text': (
+                'Specify if the CLI should return a non-zero exit code '
+                'when there are no changes to be made to the stack. By '
+                'default, a non-zero exit code is returned, and this is '
+                'the same behavior that occurs when '
+                '`--fail-on-empty-changeset` is specified. If '
+                '`--no-fail-on-empty-changeset` is specified, then the '
+                'CLI will return a zero exit code.'
+            )
+        },
+        {
+            'name': 'no-fail-on-empty-changeset',
+            'required': False,
+            'action': 'store_false',
+            'group_name': 'fail-on-empty-changeset',
+            'dest': 'fail_on_empty_changeset',
+            'default': True,
+            'help_text': (
+                'Causes the CLI to return an exit code of 0 if there are no '
+                'changes to be made to the stack.'
+            )
+        },
+        {
+            'name': TAGS_CMD,
+            'action': 'store',
+            'required': False,
+            'schema': {
+                'type': 'array',
+                'items': {
+                    'type': 'string'
+                }
+            },
+            'default': [],
+            'help_text': (
+                'A list of tags to associate with the stack that is created'
+                ' or updated. AWS CloudFormation also propagates these tags'
+                ' to resources in the stack if the resource supports it.'
+                ' Syntax: TagKey1=TagValue1 TagKey2=TagValue2 ...'
+            )
+        }
+    ]
+
+    def _run_main(self, parsed_args, parsed_globals):
+        cloudformation_client = \
+            self._session.create_client(
+                    'cloudformation', region_name=parsed_globals.region,
+                    endpoint_url=parsed_globals.endpoint_url,
+                    verify=parsed_globals.verify_ssl)
+
+        template_path = parsed_args.template_file
+        if not os.path.isfile(template_path):
+            raise exceptions.InvalidTemplatePathError(
+                    template_path=template_path)
+
+        # Parse parameters
+        with open(template_path, "r") as handle:
+            template_str = handle.read()
+
+        stack_name = parsed_args.stack_name
+        parameter_overrides = self.parse_key_value_arg(
+                parsed_args.parameter_overrides,
+                self.PARAMETER_OVERRIDE_CMD)
+
+        tags_dict = self.parse_key_value_arg(parsed_args.tags, self.TAGS_CMD)
+        tags = [{"Key": key, "Value": value}
+                for key, value in tags_dict.items()]
+
+        template_dict = yaml_parse(template_str)
+
+        parameters = self.merge_parameters(template_dict, parameter_overrides)
+
+        template_size = os.path.getsize(parsed_args.template_file)
+        if template_size > 51200 and not parsed_args.s3_bucket:
+            raise exceptions.DeployBucketRequiredError()
+
+        bucket = parsed_args.s3_bucket
+        if bucket:
+            s3_client = self._session.create_client(
+                "s3",
+                config=Config(signature_version='s3v4'),
+                region_name=parsed_globals.region,
+                verify=parsed_globals.verify_ssl)
+
+            s3_uploader = S3Uploader(s3_client,
+                                      bucket,
+                                      parsed_args.s3_prefix,
+                                      parsed_args.kms_key_id,
+                                      parsed_args.force_upload)
+        else:
+            s3_uploader = None
+
+        deployer = Deployer(cloudformation_client)
+        return self.deploy(deployer, stack_name, template_str,
+                           parameters, parsed_args.capabilities,
+                           parsed_args.execute_changeset, parsed_args.role_arn,
+                           parsed_args.notification_arns, s3_uploader,
+                           tags, parsed_args.fail_on_empty_changeset,
+                           parsed_args.disable_rollback)
+
+    def deploy(self, deployer, stack_name, template_str,
+               parameters, capabilities, execute_changeset, role_arn,
+               notification_arns, s3_uploader, tags,
+               fail_on_empty_changeset=True, disable_rollback=False):
+        try:
+            result = deployer.create_and_wait_for_changeset(
+                stack_name=stack_name,
+                cfn_template=template_str,
+                parameter_values=parameters,
+                capabilities=capabilities,
+                role_arn=role_arn,
+                notification_arns=notification_arns,
+                s3_uploader=s3_uploader,
+                tags=tags
+            )
+        except exceptions.ChangeEmptyError as ex:
+            if fail_on_empty_changeset:
+                raise
+            write_exception(ex, outfile=get_stdout_text_writer())
+            return 0
+
+        if execute_changeset:
+            deployer.execute_changeset(result.changeset_id, stack_name,
+                                       disable_rollback)
+            deployer.wait_for_execute(stack_name, result.changeset_type)
+            sys.stdout.write(self.MSG_EXECUTE_SUCCESS.format(
+                    stack_name=stack_name))
+        else:
+            sys.stdout.write(self.MSG_NO_EXECUTE_CHANGESET.format(
+                    changeset_id=result.changeset_id))
+
+        sys.stdout.flush()
+        return 0
+
+    def merge_parameters(self, template_dict, parameter_overrides):
+        """
+        CloudFormation CreateChangeset requires a value for every parameter
+        from the template, either specifying a new value or use previous value.
+        For convenience, this method will accept new parameter values and
+        generates a dict of all parameters in a format that ChangeSet API
+        will accept
+
+        :param parameter_overrides:
+        :return:
+        """
+        parameter_values = []
+
+        if not isinstance(template_dict.get("Parameters", None), dict):
+            return parameter_values
+
+        for key, value in template_dict["Parameters"].items():
+
+            obj = {
+                "ParameterKey": key
+            }
+
+            if key in parameter_overrides:
+                obj["ParameterValue"] = parameter_overrides[key]
+            else:
+                obj["UsePreviousValue"] = True
+
+            parameter_values.append(obj)
+
+        return parameter_values
+
+    def parse_key_value_arg(self, arg_value, argname):
+        """
+        Converts arguments that are passed as list of "Key=Value" strings
+        into a real dictionary.
+
+        :param arg_value list: Array of strings, where each string is of
+            form Key=Value
+        :param argname string: Name of the argument that contains the value
+        :return dict: Dictionary representing the key/value pairs
+        """
+        result = {}
+        for data in arg_value:
+
+            # Split at first '=' from left
+            key_value_pair = data.split("=", 1)
+
+            if len(key_value_pair) != 2:
+                raise exceptions.InvalidKeyValuePairArgumentError(
+                        argname=argname,
+                        value=key_value_pair)
+
+            result[key_value_pair[0]] = key_value_pair[1]
+
+        return result
+
+
+

data/lib/python3.10/site-packages/awscli/customizations/cloudformation/deployer.py

@@ -0,0 +1,232 @@
+# Copyright 2012-2015 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+# http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+import sys
+import time
+import logging
+import botocore
+import collections
+
+from awscli.customizations.cloudformation import exceptions
+from awscli.customizations.cloudformation.artifact_exporter import mktempfile, parse_s3_url
+
+from datetime import datetime
+
+LOG = logging.getLogger(__name__)
+
+ChangeSetResult = collections.namedtuple(
+                "ChangeSetResult", ["changeset_id", "changeset_type"])
+
+
+class Deployer(object):
+
+    def __init__(self, cloudformation_client,
+                 changeset_prefix="awscli-cloudformation-package-deploy-"):
+        self._client = cloudformation_client
+        self.changeset_prefix = changeset_prefix
+
+    def has_stack(self, stack_name):
+        """
+        Checks if a CloudFormation stack with given name exists
+
+        :param stack_name: Name or ID of the stack
+        :return: True if stack exists. False otherwise
+        """
+        try:
+            resp = self._client.describe_stacks(StackName=stack_name)
+            if len(resp["Stacks"]) != 1:
+                return False
+
+            # When you run CreateChangeSet on a a stack that does not exist,
+            # CloudFormation will create a stack and set it's status
+            # REVIEW_IN_PROGRESS. However this stack is cannot be manipulated
+            # by "update" commands. Under this circumstances, we treat like
+            # this stack does not exist and call CreateChangeSet will
+            # ChangeSetType set to CREATE and not UPDATE.
+            stack = resp["Stacks"][0]
+            return stack["StackStatus"] != "REVIEW_IN_PROGRESS"
+
+        except botocore.exceptions.ClientError as e:
+            # If a stack does not exist, describe_stacks will throw an
+            # exception. Unfortunately we don't have a better way than parsing
+            # the exception msg to understand the nature of this exception.
+            msg = str(e)
+
+            if "Stack with id {0} does not exist".format(stack_name) in msg:
+                LOG.debug("Stack with id {0} does not exist".format(
+                    stack_name))
+                return False
+            else:
+                # We don't know anything about this exception. Don't handle
+                LOG.debug("Unable to get stack details.", exc_info=e)
+                raise e
+
+    def create_changeset(self, stack_name, cfn_template,
+                         parameter_values, capabilities, role_arn,
+                         notification_arns, s3_uploader, tags):
+        """
+        Call Cloudformation to create a changeset and wait for it to complete
+
+        :param stack_name: Name or ID of stack
+        :param cfn_template: CloudFormation template string
+        :param parameter_values: Template parameters object
+        :param capabilities: Array of capabilities passed to CloudFormation
+        :param tags: Array of tags passed to CloudFormation
+        :return:
+        """
+
+        now = datetime.utcnow().isoformat()
+        description = "Created by AWS CLI at {0} UTC".format(now)
+
+        # Each changeset will get a unique name based on time
+        changeset_name = self.changeset_prefix + str(int(time.time()))
+
+        if not self.has_stack(stack_name):
+            changeset_type = "CREATE"
+            # When creating a new stack, UsePreviousValue=True is invalid.
+            # For such parameters, users should either override with new value,
+            # or set a Default value in template to successfully create a stack.
+            parameter_values = [x for x in parameter_values
+                                if not x.get("UsePreviousValue", False)]
+        else:
+            changeset_type = "UPDATE"
+            # UsePreviousValue not valid if parameter is new
+            summary = self._client.get_template_summary(StackName=stack_name)
+            existing_parameters = [parameter['ParameterKey'] for parameter in \
+                                   summary['Parameters']]
+            parameter_values = [x for x in parameter_values
+                                if not (x.get("UsePreviousValue", False) and \
+                                x["ParameterKey"] not in existing_parameters)]
+
+        kwargs = {
+            'ChangeSetName': changeset_name,
+            'StackName': stack_name,
+            'TemplateBody': cfn_template,
+            'ChangeSetType': changeset_type,
+            'Parameters': parameter_values,
+            'Capabilities': capabilities,
+            'Description': description,
+            'Tags': tags,
+        }
+
+        # If an S3 uploader is available, use TemplateURL to deploy rather than
+        # TemplateBody. This is required for large templates.
+        if s3_uploader:
+            with mktempfile() as temporary_file:
+                temporary_file.write(kwargs.pop('TemplateBody'))
+                temporary_file.flush()
+                url = s3_uploader.upload_with_dedup(
+                        temporary_file.name, "template")
+                # TemplateUrl property requires S3 URL to be in path-style format
+                parts = parse_s3_url(url, version_property="Version")
+                kwargs['TemplateURL'] = s3_uploader.to_path_style_s3_url(parts["Key"], parts.get("Version", None))
+
+        # don't set these arguments if not specified to use existing values
+        if role_arn is not None:
+            kwargs['RoleARN'] = role_arn
+        if notification_arns is not None:
+            kwargs['NotificationARNs'] = notification_arns
+        try:
+            resp = self._client.create_change_set(**kwargs)
+            return ChangeSetResult(resp["Id"], changeset_type)
+        except Exception as ex:
+            LOG.debug("Unable to create changeset", exc_info=ex)
+            raise ex
+
+    def wait_for_changeset(self, changeset_id, stack_name):
+        """
+        Waits until the changeset creation completes
+
+        :param changeset_id: ID or name of the changeset
+        :param stack_name:   Stack name
+        :return: Latest status of the create-change-set operation
+        """
+        sys.stdout.write("\nWaiting for changeset to be created..\n")
+        sys.stdout.flush()
+
+        # Wait for changeset to be created
+        waiter = self._client.get_waiter("change_set_create_complete")
+        # Poll every 5 seconds. Changeset creation should be fast
+        waiter_config = {'Delay': 5}
+        try:
+            waiter.wait(ChangeSetName=changeset_id, StackName=stack_name,
+                        WaiterConfig=waiter_config)
+        except botocore.exceptions.WaiterError as ex:
+            LOG.debug("Create changeset waiter exception", exc_info=ex)
+
+            resp = ex.last_response
+            status = resp["Status"]
+            reason = resp["StatusReason"]
+
+            if status == "FAILED" and \
+               "The submitted information didn't contain changes." in reason or \
+                            "No updates are to be performed" in reason:
+                    raise exceptions.ChangeEmptyError(stack_name=stack_name)
+
+            raise RuntimeError("Failed to create the changeset: {0} "
+                               "Status: {1}. Reason: {2}"
+                               .format(ex, status, reason))
+
+    def execute_changeset(self, changeset_id, stack_name,
+                          disable_rollback=False):
+        """
+        Calls CloudFormation to execute changeset
+
+        :param changeset_id: ID of the changeset
+        :param stack_name: Name or ID of the stack
+        :param disable_rollback: Disable rollback of all resource changes
+        :return: Response from execute-change-set call
+        """
+        return self._client.execute_change_set(
+                ChangeSetName=changeset_id,
+                StackName=stack_name,
+                DisableRollback=disable_rollback)
+
+    def wait_for_execute(self, stack_name, changeset_type):
+
+        sys.stdout.write("Waiting for stack create/update to complete\n")
+        sys.stdout.flush()
+
+        # Pick the right waiter
+        if changeset_type == "CREATE":
+            waiter = self._client.get_waiter("stack_create_complete")
+        elif changeset_type == "UPDATE":
+            waiter = self._client.get_waiter("stack_update_complete")
+        else:
+            raise RuntimeError("Invalid changeset type {0}"
+                               .format(changeset_type))
+
+        # Poll every 30 seconds. Polling too frequently risks hitting rate limits
+        # on CloudFormation's DescribeStacks API
+        waiter_config = {
+            'Delay': 30,
+            'MaxAttempts': 120,
+        }
+
+        try:
+            waiter.wait(StackName=stack_name, WaiterConfig=waiter_config)
+        except botocore.exceptions.WaiterError as ex:
+            LOG.debug("Execute changeset waiter exception", exc_info=ex)
+
+            raise exceptions.DeployFailedError(stack_name=stack_name)
+
+    def create_and_wait_for_changeset(self, stack_name, cfn_template,
+                                      parameter_values, capabilities, role_arn,
+                                      notification_arns, s3_uploader, tags):
+
+        result = self.create_changeset(
+                stack_name, cfn_template, parameter_values, capabilities,
+                role_arn, notification_arns, s3_uploader, tags)
+        self.wait_for_changeset(result.changeset_id, stack_name)
+
+        return result

data/lib/python3.10/site-packages/awscli/customizations/cloudformation/exceptions.py

@@ -0,0 +1,59 @@
+
+class CloudFormationCommandError(Exception):
+    fmt = 'An unspecified error occurred'
+
+    def __init__(self, **kwargs):
+        msg = self.fmt.format(**kwargs)
+        Exception.__init__(self, msg)
+        self.kwargs = kwargs
+
+
+class InvalidTemplatePathError(CloudFormationCommandError):
+    fmt = "Invalid template path {template_path}"
+
+
+class ChangeEmptyError(CloudFormationCommandError):
+    fmt = "No changes to deploy. Stack {stack_name} is up to date"
+
+
+class InvalidLocalPathError(CloudFormationCommandError):
+    fmt = ("Parameter {property_name} of resource {resource_id} refers "
+           "to a file or folder that does not exist {local_path}")
+
+
+class InvalidTemplateUrlParameterError(CloudFormationCommandError):
+    fmt = ("{property_name} parameter of {resource_id} resource is invalid. "
+           "It must be a S3 URL or path to CloudFormation "
+           "template file. Actual: {template_path}")
+
+
+class ExportFailedError(CloudFormationCommandError):
+    fmt = ("Unable to upload artifact {property_value} referenced "
+           "by {property_name} parameter of {resource_id} resource."
+           "\n"
+           "{ex}")
+
+
+class InvalidKeyValuePairArgumentError(CloudFormationCommandError):
+    fmt = ("{value} value passed to --{argname} must be of format "
+           "Key=Value")
+
+
+class DeployFailedError(CloudFormationCommandError):
+    fmt = \
+        ("Failed to create/update the stack. Run the following command"
+         "\n"
+         "to fetch the list of events leading up to the failure"
+         "\n"
+         "aws cloudformation describe-stack-events --stack-name {stack_name}")
+
+class DeployBucketRequiredError(CloudFormationCommandError):
+    fmt = \
+        ("Templates with a size greater than 51,200 bytes must be deployed "
+         "via an S3 Bucket. Please add the --s3-bucket parameter to your "
+         "command. The local template will be copied to that S3 bucket and "
+         "then deployed.")
+
+
+class InvalidForEachIntrinsicFunctionError(CloudFormationCommandError):
+    fmt = 'The value of {resource_id} has an invalid "Fn::ForEach::" format: Must be a list of three entries'

data/lib/python3.10/site-packages/awscli/customizations/cloudformation/package.py

@@ -0,0 +1,181 @@
+# Copyright 2012-2015 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+# http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+import os
+import logging
+import sys
+
+import json
+
+from botocore.client import Config
+
+from awscli.customizations.cloudformation.artifact_exporter import Template
+from awscli.customizations.cloudformation.yamlhelper import yaml_dump
+from awscli.customizations.cloudformation import exceptions
+from awscli.customizations.commands import BasicCommand
+from awscli.customizations.s3uploader import S3Uploader
+
+LOG = logging.getLogger(__name__)
+
+
+class PackageCommand(BasicCommand):
+
+    MSG_PACKAGED_TEMPLATE_WRITTEN = (
+        "Successfully packaged artifacts and wrote output template "
+        "to file {output_file_name}."
+        "\n"
+        "Execute the following command to deploy the packaged template"
+        "\n"
+        "aws cloudformation deploy --template-file {output_file_path} "
+        "--stack-name <YOUR STACK NAME>"
+        "\n")
+
+    NAME = "package"
+
+    DESCRIPTION = BasicCommand.FROM_FILE("cloudformation",
+                                         "_package_description.rst")
+
+    ARG_TABLE = [
+        {
+            'name': 'template-file',
+            'required': True,
+            'help_text': (
+                'The path where your AWS CloudFormation'
+                ' template is located.'
+            )
+        },
+
+        {
+            'name': 's3-bucket',
+            'required': True,
+            'help_text': (
+                'The name of the S3 bucket where this command uploads'
+                ' the artifacts that are referenced in your template.'
+            )
+        },
+
+        {
+            'name': 's3-prefix',
+            'help_text': (
+                'A prefix name that the command adds to the'
+                ' artifacts\' name when it uploads them to the S3 bucket.'
+                ' The prefix name is a path name (folder name) for'
+                ' the S3 bucket.'
+            )
+        },
+
+        {
+            'name': 'kms-key-id',
+            'help_text': (
+                'The ID of an AWS KMS key that the command uses'
+                ' to encrypt artifacts that are at rest in the S3 bucket.'
+            )
+        },
+
+        {
+            "name": "output-template-file",
+            "help_text": (
+                "The path to the file where the command writes the"
+                " output AWS CloudFormation template. If you don't specify"
+                " a path, the command writes the template to the standard"
+                " output."
+            )
+        },
+
+        {
+            "name": "use-json",
+            "action": "store_true",
+            "help_text": (
+                "Indicates whether to use JSON as the format for the output AWS"
+                " CloudFormation template. YAML is used by default."
+            )
+        },
+
+        {
+            "name": "force-upload",
+            "action": "store_true",
+            "help_text": (
+                'Indicates whether to override existing files in the S3 bucket.'
+                ' Specify this flag to upload artifacts even if they '
+                ' match existing artifacts in the S3 bucket.'
+            )
+        },
+        {
+            "name": "metadata",
+            "cli_type_name": "map",
+            "schema": {
+                "type": "map",
+                "key": {"type": "string"},
+                "value": {"type": "string"}
+            },
+            "help_text": "A map of metadata to attach to *ALL* the artifacts that"
+            " are referenced in your template."
+        }
+    ]
+
+    def _run_main(self, parsed_args, parsed_globals):
+        s3_client = self._session.create_client(
+            "s3",
+            config=Config(signature_version='s3v4'),
+            region_name=parsed_globals.region,
+            verify=parsed_globals.verify_ssl)
+
+        template_path = parsed_args.template_file
+        if not os.path.isfile(template_path):
+            raise exceptions.InvalidTemplatePathError(
+                    template_path=template_path)
+
+        bucket = parsed_args.s3_bucket
+
+        self.s3_uploader = S3Uploader(s3_client,
+                                      bucket,
+                                      parsed_args.s3_prefix,
+                                      parsed_args.kms_key_id,
+                                      parsed_args.force_upload)
+        # attach the given metadata to the artifacts to be uploaded
+        self.s3_uploader.artifact_metadata = parsed_args.metadata
+
+        output_file = parsed_args.output_template_file
+        use_json = parsed_args.use_json
+        exported_str = self._export(template_path, use_json)
+
+        sys.stdout.write("\n")
+        self.write_output(output_file, exported_str)
+
+        if output_file:
+            msg = self.MSG_PACKAGED_TEMPLATE_WRITTEN.format(
+                    output_file_name=output_file,
+                    output_file_path=os.path.abspath(output_file))
+            sys.stdout.write(msg)
+
+        sys.stdout.flush()
+        return 0
+
+    def _export(self, template_path, use_json):
+        template = Template(template_path, os.getcwd(), self.s3_uploader)
+        exported_template = template.export()
+
+        if use_json:
+            exported_str = json.dumps(exported_template, indent=4, ensure_ascii=False)
+        else:
+            exported_str = yaml_dump(exported_template)
+
+        return exported_str
+
+    def write_output(self, output_file_name, data):
+        if output_file_name is None:
+            sys.stdout.write(data)
+            return
+
+        with open(output_file_name, "w") as fp:
+            fp.write(data)

data/lib/python3.10/site-packages/awscli/customizations/cloudformation/yamlhelper.py

@@ -0,0 +1,104 @@
+# Copyright 2012-2015 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+# http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+from botocore.compat import json
+from botocore.compat import OrderedDict
+
+import yaml
+from yaml.resolver import ScalarNode, SequenceNode
+
+
+def intrinsics_multi_constructor(loader, tag_prefix, node):
+    """
+    YAML constructor to parse CloudFormation intrinsics.
+    This will return a dictionary with key being the intrinsic name
+    """
+
+    # Get the actual tag name excluding the first exclamation
+    tag = node.tag[1:]
+
+    # Some intrinsic functions doesn't support prefix "Fn::"
+    prefix = "Fn::"
+    if tag in ["Ref", "Condition"]:
+        prefix = ""
+
+    cfntag = prefix + tag
+
+    if tag == "GetAtt" and isinstance(node.value, str):
+        # ShortHand notation for !GetAtt accepts Resource.Attribute format
+        # while the standard notation is to use an array
+        # [Resource, Attribute]. Convert shorthand to standard format
+        value = node.value.split(".", 1)
+
+    elif isinstance(node, ScalarNode):
+        # Value of this node is scalar
+        value = loader.construct_scalar(node)
+
+    elif isinstance(node, SequenceNode):
+        # Value of this node is an array (Ex: [1,2])
+        value = loader.construct_sequence(node)
+
+    else:
+        # Value of this node is an mapping (ex: {foo: bar})
+        value = loader.construct_mapping(node)
+
+    return {cfntag: value}
+
+
+def _dict_representer(dumper, data):
+    return dumper.represent_dict(data.items())
+
+
+def yaml_dump(dict_to_dump):
+    """
+    Dumps the dictionary as a YAML document
+    :param dict_to_dump:
+    :return:
+    """
+    FlattenAliasDumper.add_representer(OrderedDict, _dict_representer)
+    return yaml.dump(
+        dict_to_dump,
+        default_flow_style=False,
+        Dumper=FlattenAliasDumper,
+    )
+
+
+def _dict_constructor(loader, node):
+    # Necessary in order to make yaml merge tags work
+    loader.flatten_mapping(node)
+    return OrderedDict(loader.construct_pairs(node))
+
+
+class SafeLoaderWrapper(yaml.SafeLoader):
+    """Isolated safe loader to allow for customizations without global changes.
+    """
+
+    pass
+
+def yaml_parse(yamlstr):
+    """Parse a yaml string"""
+    try:
+        # PyYAML doesn't support json as well as it should, so if the input
+        # is actually just json it is better to parse it with the standard
+        # json parser.
+        return json.loads(yamlstr, object_pairs_hook=OrderedDict)
+    except ValueError:
+        loader = SafeLoaderWrapper
+        loader.add_constructor(yaml.resolver.BaseResolver.DEFAULT_MAPPING_TAG, 
+                               _dict_constructor)
+        loader.add_multi_constructor("!", intrinsics_multi_constructor)
+        return yaml.load(yamlstr, loader)
+
+
+class FlattenAliasDumper(yaml.SafeDumper):
+    def ignore_aliases(self, data):
+        return True

data/lib/python3.10/site-packages/awscli/customizations/dlm/__init__.py

@@ -0,0 +1,12 @@
+# Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.

data/lib/python3.10/site-packages/awscli/customizations/dlm/constants.py

@@ -0,0 +1,53 @@
+# Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+# Declare all the constants used by Lifecycle in this file
+
+# Lifecycle role names
+LIFECYCLE_DEFAULT_ROLE_NAME = "AWSDataLifecycleManagerDefaultRole"
+LIFECYCLE_DEFAULT_ROLE_NAME_AMI = \
+    "AWSDataLifecycleManagerDefaultRoleForAMIManagement"
+
+# Lifecycle role arn names
+LIFECYCLE_DEFAULT_MANAGED_POLICY_NAME = "AWSDataLifecycleManagerServiceRole"
+LIFECYCLE_DEFAULT_MANAGED_POLICY_NAME_AMI = \
+    "AWSDataLifecycleManagerServiceRoleForAMIManagement"
+
+POLICY_ARN_PATTERN = "arn:{0}:iam::aws:policy/service-role/{1}"
+
+# Assume Role Policy definitions for roles
+LIFECYCLE_DEFAULT_ROLE_ASSUME_POLICY = {
+    "Version": "2012-10-17",
+    "Statement": [
+        {
+            "Sid": "",
+            "Effect": "Allow",
+            "Principal": {"Service": "dlm.amazonaws.com"},
+            "Action": "sts:AssumeRole"
+        }
+    ]
+}
+
+RESOURCE_TYPE_SNAPSHOT = "snapshot"
+RESOURCE_TYPE_IMAGE = "image"
+
+RESOURCES = {
+    RESOURCE_TYPE_SNAPSHOT: {
+        'default_role_name': LIFECYCLE_DEFAULT_ROLE_NAME,
+        'default_policy_name': LIFECYCLE_DEFAULT_MANAGED_POLICY_NAME
+    },
+    RESOURCE_TYPE_IMAGE: {
+        'default_role_name': LIFECYCLE_DEFAULT_ROLE_NAME_AMI,
+        'default_policy_name': LIFECYCLE_DEFAULT_MANAGED_POLICY_NAME_AMI
+    }
+}

data/lib/python3.10/site-packages/awscli/customizations/dlm/createdefaultrole.py

@@ -0,0 +1,167 @@
+# Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+# Class to create default roles for lifecycle
+import logging
+from awscli.clidriver import CLIOperationCaller
+from awscli.customizations.utils import get_policy_arn_suffix
+from awscli.customizations.commands import BasicCommand
+from awscli.customizations.dlm.iam import IAM
+from awscli.customizations.dlm.constants \
+    import RESOURCES, \
+    LIFECYCLE_DEFAULT_ROLE_ASSUME_POLICY, \
+    POLICY_ARN_PATTERN, \
+    RESOURCE_TYPE_SNAPSHOT, \
+    RESOURCE_TYPE_IMAGE
+
+LOG = logging.getLogger(__name__)
+
+
+def _construct_result(create_role_response, get_policy_response):
+    get_policy_response.pop('ResponseMetadata', None)
+    create_role_response.pop('ResponseMetadata', None)
+    result = {'RolePolicy': get_policy_response}
+    result.update(create_role_response)
+    return result
+
+
+# Display the result as formatted json
+def display_response(session, operation_name, result, parsed_globals):
+    if result is not None:
+        cli_operation_caller = CLIOperationCaller(session)
+        # Calling a private method. Should be changed after the functionality
+        # is moved outside CliOperationCaller.
+        cli_operation_caller._display_response(
+            operation_name, result, parsed_globals)
+
+
+# Get policy arn from region and policy name
+def get_policy_arn(region, policy_name):
+    region_suffix = get_policy_arn_suffix(region)
+    role_arn = POLICY_ARN_PATTERN.format(region_suffix, policy_name)
+    return role_arn
+
+
+# Method to parse the arguments to get the region value
+def get_region(session, parsed_globals):
+    region = parsed_globals.region
+    if region is None:
+        region = session.get_config_variable('region')
+    return region
+
+
+class CreateDefaultRole(BasicCommand):
+    NAME = "create-default-role"
+    DESCRIPTION = ('Creates the default IAM role '
+                   ' which will be used by Lifecycle service.\n'
+                   'If the role does not exist, create-default-role '
+                   'will automatically create it and set its policy.'
+                   ' If the role has been already '
+                   'created, create-default-role'
+                   ' will not update its policy.'
+                   '\n')
+    ARG_TABLE = [
+        {'name': 'iam-endpoint',
+         'no_paramfile': True,
+         'help_text': '<p>The IAM endpoint to call for creating the roles.'
+                      ' This is optional and should only be specified when a'
+                      ' custom endpoint should be called for IAM operations'
+                      '.</p>'},
+        {'name': 'resource-type',
+         'default': RESOURCE_TYPE_SNAPSHOT,
+         'choices': [RESOURCE_TYPE_SNAPSHOT, RESOURCE_TYPE_IMAGE],
+         'help_text': (
+                 "<p>The resource type for which the role needs to be created."
+                 " The available options are '%s' and '%s'."
+                 " This parameter defaults to '%s'.</p>"
+                 % (RESOURCE_TYPE_SNAPSHOT, RESOURCE_TYPE_IMAGE,
+                    RESOURCE_TYPE_SNAPSHOT))}
+
+    ]
+
+    def __init__(self, session):
+        super(CreateDefaultRole, self).__init__(session)
+
+    def _run_main(self, parsed_args, parsed_globals):
+        """Call to run the commands"""
+
+        self._region = get_region(self._session, parsed_globals)
+        self._endpoint_url = parsed_args.iam_endpoint
+        self._resource_type = parsed_args.resource_type
+        self._iam_client = IAM(self._session.create_client(
+            'iam',
+            region_name=self._region,
+            endpoint_url=self._endpoint_url,
+            verify=parsed_globals.verify_ssl
+        ))
+
+        result = self._create_default_role_if_not_exists(parsed_globals)
+
+        display_response(
+            self._session,
+            'create_role',
+            result,
+            parsed_globals
+        )
+
+        return 0
+
+    def _create_default_role_if_not_exists(self, parsed_globals):
+        """Method to create default lifecycle role
+            if it doesn't exist already
+        """
+
+        role_name = RESOURCES[self._resource_type]['default_role_name']
+        assume_role_policy = LIFECYCLE_DEFAULT_ROLE_ASSUME_POLICY
+
+        if self._iam_client.check_if_role_exists(role_name):
+            LOG.debug('Role %s exists', role_name)
+            return None
+
+        LOG.debug('Role %s does not exist. '
+                  'Creating default role for Lifecycle', role_name)
+
+        # Get Region
+        region = get_region(self._session, parsed_globals)
+
+        if region is None:
+            raise ValueError('You must specify a region. '
+                             'You can also configure your region '
+                             'by running "aws configure".')
+
+        managed_policy_arn = get_policy_arn(
+            region,
+            RESOURCES[self._resource_type]['default_policy_name']
+        )
+
+        # Don't proceed if managed policy does not exist
+        if not self._iam_client.check_if_policy_exists(managed_policy_arn):
+            LOG.debug('Managed Policy %s does not exist.', managed_policy_arn)
+            return None
+
+        LOG.debug('Managed Policy %s exists.', managed_policy_arn)
+        # Create default role
+        create_role_response = \
+            self._iam_client.create_role_with_trust_policy(
+                role_name,
+                assume_role_policy
+            )
+        # Attach policy to role
+        self._iam_client.attach_policy_to_role(
+            managed_policy_arn,
+            role_name
+        )
+
+        # Construct result
+        get_policy_response = self._iam_client.get_policy(managed_policy_arn)
+        return _construct_result(create_role_response, get_policy_response)

data/lib/python3.10/site-packages/awscli/customizations/dlm/dlm.py

@@ -0,0 +1,30 @@
+# Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+from awscli.customizations.dlm.createdefaultrole import CreateDefaultRole
+
+
+def dlm_initialize(cli):
+    """
+    The entry point for Lifecycle high level commands.
+    """
+    cli.register('building-command-table.dlm', register_commands)
+
+
+def register_commands(command_table, session, **kwargs):
+    """
+    Called when the Lifecycle command table is being built. Used to inject new
+    high level commands into the command list. These high level commands
+    must not collide with existing low-level API call names.
+    """
+    command_table['create-default-role'] = CreateDefaultRole(session)

data/lib/python3.10/site-packages/awscli/customizations/dlm/iam.py

@@ -0,0 +1,51 @@
+import json
+
+
+class IAM(object):
+
+    def __init__(self, iam_client):
+        self.iam_client = iam_client
+
+    def check_if_role_exists(self, role_name):
+        """Method to verify if a particular role exists"""
+        try:
+            self.iam_client.get_role(RoleName=role_name)
+        except self.iam_client.exceptions.NoSuchEntityException:
+            return False
+        return True
+
+    def check_if_policy_exists(self, policy_arn):
+        """Method to verify if a particular policy exists"""
+        try:
+            self.iam_client.get_policy(PolicyArn=policy_arn)
+        except self.iam_client.exceptions.NoSuchEntityException:
+            return False
+        return True
+
+    def attach_policy_to_role(self, policy_arn, role_name):
+        """Method to attach LifecyclePolicy to role specified by role_name"""
+        return self.iam_client.attach_role_policy(
+            PolicyArn=policy_arn,
+            RoleName=role_name
+        )
+
+    def create_role_with_trust_policy(self, role_name, assume_role_policy):
+        """Method to create role with a given role name
+            and assume_role_policy
+        """
+        return self.iam_client.create_role(
+            RoleName=role_name,
+            AssumeRolePolicyDocument=json.dumps(assume_role_policy))
+
+    def get_policy(self, arn):
+        """Method to get the Policy for a particular ARN
+        This is used to display the policy contents to the user
+        """
+        pol_det = self.iam_client.get_policy(PolicyArn=arn)
+        policy_version_details = self.iam_client.get_policy_version(
+            PolicyArn=arn,
+            VersionId=pol_det.get("Policy", {}).get("DefaultVersionId", "")
+        )
+        return policy_version_details\
+            .get("PolicyVersion", {})\
+            .get("Document", {})

data/lib/python3.10/site-packages/awscli/customizations/eks/__init__.py

@@ -0,0 +1,31 @@
+# Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+# http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+from awscli.customizations.eks.update_kubeconfig import UpdateKubeconfigCommand
+from awscli.customizations.eks.get_token import GetTokenCommand
+
+
+def initialize(cli):
+    """
+    The entry point for EKS high level commands.
+    """
+    cli.register('building-command-table.eks', inject_commands)
+
+
+def inject_commands(command_table, session, **kwargs):
+    """
+    Called when the EKS command table is being built.
+    Used to inject new high level commands into the command list.
+    """
+    command_table['update-kubeconfig'] = UpdateKubeconfigCommand(session)
+    command_table['get-token'] = GetTokenCommand(session)

data/lib/python3.10/site-packages/awscli/customizations/eks/exceptions.py

@@ -0,0 +1,20 @@
+# Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+# http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+
+class EKSError(Exception):
+    """ Base class for all EKSErrors."""
+
+
+class EKSClusterError(EKSError):
+    """ Raised when a cluster is not in the correct state."""

data/lib/python3.10/site-packages/awscli/customizations/eks/get_token.py

@@ -0,0 +1,276 @@
+# Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+# http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+import base64
+import botocore
+import json
+import os
+import sys
+
+from datetime import datetime, timedelta
+from botocore.signers import RequestSigner
+from botocore.model import ServiceId
+
+from awscli.formatter import get_formatter
+from awscli.customizations.commands import BasicCommand
+from awscli.customizations.utils import uni_print
+from awscli.customizations.utils import validate_mutually_exclusive
+
+AUTH_SERVICE = "sts"
+AUTH_COMMAND = "GetCallerIdentity"
+AUTH_API_VERSION = "2011-06-15"
+AUTH_SIGNING_VERSION = "v4"
+
+ALPHA_API = "client.authentication.k8s.io/v1alpha1"
+BETA_API = "client.authentication.k8s.io/v1beta1"
+V1_API = "client.authentication.k8s.io/v1"
+
+FULLY_SUPPORTED_API_VERSIONS = [
+    V1_API,
+    BETA_API,
+]
+DEPRECATED_API_VERSIONS = [
+    ALPHA_API,
+]
+
+ERROR_MSG_TPL = (
+    "{0} KUBERNETES_EXEC_INFO, defaulting to {1}. This is likely a "
+    "bug in your Kubernetes client. Please update your Kubernetes "
+    "client."
+)
+UNRECOGNIZED_MSG_TPL = (
+    "Unrecognized API version in KUBERNETES_EXEC_INFO, defaulting to "
+    "{0}. This is likely due to an outdated AWS "
+    "CLI. Please update your AWS CLI."
+)
+DEPRECATION_MSG_TPL = (
+    "Kubeconfig user entry is using deprecated API version {0}. Run "
+    "'aws eks update-kubeconfig' to update."
+)
+
+# Presigned url timeout in seconds
+URL_TIMEOUT = 60
+
+TOKEN_EXPIRATION_MINS = 14
+
+TOKEN_PREFIX = 'k8s-aws-v1.'
+
+K8S_AWS_ID_HEADER = 'x-k8s-aws-id'
+
+
+class GetTokenCommand(BasicCommand):
+    NAME = 'get-token'
+
+    DESCRIPTION = (
+        "Get a token for authentication with an Amazon EKS cluster. "
+        "This can be used as an alternative to the "
+        "aws-iam-authenticator."
+    )
+
+    ARG_TABLE = [
+        {
+            'name': 'cluster-name',
+            'help_text': (
+                "Specify the name of the Amazon EKS cluster to create a token for. (Note: for local clusters on AWS Outposts, please use --cluster-id parameter)"
+            ),
+            'required': False,
+        },
+        {
+            'name': 'role-arn',
+            'help_text': (
+                "Assume this role for credentials when signing the token. "
+                "Use this optional parameter when the credentials for signing "
+                "the token differ from that of the current role session. "
+                "Using this parameter results in new role session credentials "
+                "that are used to sign the token."
+            ),
+            'required': False,
+        },
+        {
+            'name': 'cluster-id',
+            # When EKS in-region cluster supports cluster-id, we will need to update this help text
+            'help_text': (
+                "Specify the id of the Amazon EKS cluster to create a token for. (Note: for local clusters on AWS Outposts only)"
+            ),
+            'required': False,
+        },
+    ]
+
+    def get_expiration_time(self):
+        token_expiration = datetime.utcnow() + timedelta(
+            minutes=TOKEN_EXPIRATION_MINS
+        )
+        return token_expiration.strftime('%Y-%m-%dT%H:%M:%SZ')
+
+    def _run_main(self, parsed_args, parsed_globals):
+        client_factory = STSClientFactory(self._session)
+        sts_client = client_factory.get_sts_client(
+            region_name=parsed_globals.region, role_arn=parsed_args.role_arn
+        )
+        
+        validate_mutually_exclusive(parsed_args, ['cluster_name'], ['cluster_id'])
+
+        if parsed_args.cluster_id:
+            identifier = parsed_args.cluster_id
+        elif parsed_args.cluster_name:
+            identifier = parsed_args.cluster_name
+        else:
+            return ValueError("Either parameter --cluster-name or --cluster-id must be specified.")
+
+        token = TokenGenerator(sts_client).get_token(identifier)
+
+        # By default STS signs the url for 15 minutes so we are creating a
+        # rfc3339 timestamp with expiration in 14 minutes as part of the token, which
+        # is used by some clients (client-go) who will refresh the token after 14 mins
+        token_expiration = self.get_expiration_time()
+
+        full_object = {
+            "kind": "ExecCredential",
+            "apiVersion": self.discover_api_version(),
+            "spec": {},
+            "status": {
+                "expirationTimestamp": token_expiration,
+                "token": token,
+            },
+        }
+
+        output = parsed_globals.output
+        if output is None:
+            output = self._session.get_config_variable('output')
+        formatter = get_formatter(output, parsed_globals)
+        formatter.query = parsed_globals.query
+
+        formatter(self.NAME, full_object)
+        uni_print('\n')
+        return 0
+
+    def discover_api_version(self):
+        """
+        Parses the KUBERNETES_EXEC_INFO environment variable and returns the
+        API version. If the environment variable is malformed or invalid,
+        return the v1beta1 response and print a message to stderr.
+
+        If the v1alpha1 API is specified explicitly, a message is printed to
+        stderr with instructions to update.
+
+        :return: The client authentication API version
+        :rtype: string
+        """
+        # At the time Kubernetes v1.29 is released upstream (approx Dec 2023),
+        # "v1beta1" will be removed. At or around that time, EKS will likely
+        # support v1.22 through v1.28, in which client API version "v1beta1"
+        # will be supported by all EKS versions.
+        fallback_api_version = BETA_API
+
+        error_prefixes = {
+            "error": "Error parsing",
+            "empty": "Empty",
+        }
+
+        exec_info_raw = os.environ.get("KUBERNETES_EXEC_INFO", "")
+        if not exec_info_raw:
+            # All kube clients should be setting this, but client-go clients
+            # (kubectl, kubelet, etc) < 1.20 were not setting this if the API
+            # version defined in the kubeconfig was not v1alpha1.
+            #
+            # This was changed in kubernetes/kubernetes#95489 so that
+            # KUBERNETES_EXEC_INFO is always provided
+            return fallback_api_version
+        try:
+            exec_info = json.loads(exec_info_raw)
+        except json.JSONDecodeError:
+            # The environment variable was malformed
+            uni_print(
+                ERROR_MSG_TPL.format(
+                    error_prefixes["error"],
+                    fallback_api_version,
+                ),
+                sys.stderr,
+            )
+            uni_print("\n", sys.stderr)
+            return fallback_api_version
+
+        api_version_raw = exec_info.get("apiVersion")
+        if api_version_raw in FULLY_SUPPORTED_API_VERSIONS:
+            return api_version_raw
+        elif api_version_raw in DEPRECATED_API_VERSIONS:
+            uni_print(DEPRECATION_MSG_TPL.format(api_version_raw), sys.stderr)
+            uni_print("\n", sys.stderr)
+            return api_version_raw
+        else:
+            uni_print(
+                UNRECOGNIZED_MSG_TPL.format(fallback_api_version),
+                sys.stderr,
+            )
+            uni_print("\n", sys.stderr)
+            return fallback_api_version
+
+
+class TokenGenerator(object):
+    def __init__(self, sts_client):
+        self._sts_client = sts_client
+
+    def get_token(self, k8s_aws_id):
+        """Generate a presigned url token to pass to kubectl."""
+        url = self._get_presigned_url(k8s_aws_id)
+        token = TOKEN_PREFIX + base64.urlsafe_b64encode(
+            url.encode('utf-8')
+        ).decode('utf-8').rstrip('=')
+        return token
+
+    def _get_presigned_url(self, k8s_aws_id):
+        return self._sts_client.generate_presigned_url(
+            'get_caller_identity',
+            Params={K8S_AWS_ID_HEADER: k8s_aws_id},
+            ExpiresIn=URL_TIMEOUT,
+            HttpMethod='GET',
+        )
+
+
+class STSClientFactory(object):
+    def __init__(self, session):
+        self._session = session
+
+    def get_sts_client(self, region_name=None, role_arn=None):
+        client_kwargs = {'region_name': region_name}
+        if role_arn is not None:
+            creds = self._get_role_credentials(region_name, role_arn)
+            client_kwargs['aws_access_key_id'] = creds['AccessKeyId']
+            client_kwargs['aws_secret_access_key'] = creds['SecretAccessKey']
+            client_kwargs['aws_session_token'] = creds['SessionToken']
+        sts = self._session.create_client('sts', **client_kwargs)
+        self._register_k8s_aws_id_handlers(sts)
+        return sts
+
+    def _get_role_credentials(self, region_name, role_arn):
+        sts = self._session.create_client('sts', region_name)
+        return sts.assume_role(
+            RoleArn=role_arn, RoleSessionName='EKSGetTokenAuth'
+        )['Credentials']
+
+    def _register_k8s_aws_id_handlers(self, sts_client):
+        sts_client.meta.events.register(
+            'provide-client-params.sts.GetCallerIdentity',
+            self._retrieve_k8s_aws_id,
+        )
+        sts_client.meta.events.register(
+            'before-sign.sts.GetCallerIdentity',
+            self._inject_k8s_aws_id_header,
+        )
+
+    def _retrieve_k8s_aws_id(self, params, context, **kwargs):
+        if K8S_AWS_ID_HEADER in params:
+            context[K8S_AWS_ID_HEADER] = params.pop(K8S_AWS_ID_HEADER)
+
+    def _inject_k8s_aws_id_header(self, request, **kwargs):
+        if K8S_AWS_ID_HEADER in request.context:
+            request.headers[K8S_AWS_ID_HEADER] = request.context[K8S_AWS_ID_HEADER]

data/lib/python3.10/site-packages/awscli/customizations/eks/kubeconfig.py

@@ -0,0 +1,281 @@
+# Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+# http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+import os
+import yaml
+import logging
+import errno
+from botocore.compat import OrderedDict
+
+from awscli.customizations.eks.exceptions import EKSError
+from awscli.customizations.eks.ordered_yaml import (ordered_yaml_load,
+                                                    ordered_yaml_dump)
+
+
+class KubeconfigError(EKSError):
+    """ Base class for all kubeconfig errors."""
+
+
+class KubeconfigCorruptedError(KubeconfigError):
+    """ Raised when a kubeconfig cannot be parsed."""
+
+
+class KubeconfigInaccessableError(KubeconfigError):
+    """ Raised when a kubeconfig cannot be opened for read/writing."""
+
+
+def _get_new_kubeconfig_content():
+    return OrderedDict([
+        ("apiVersion", "v1"),
+        ("clusters", []),
+        ("contexts", []),
+        ("current-context", ""),
+        ("kind", "Config"),
+        ("preferences", OrderedDict()),
+        ("users", [])
+    ])
+
+
+class Kubeconfig(object):
+    def __init__(self, path, content=None):
+        self.path = path
+        if content is None:
+            content = _get_new_kubeconfig_content()
+        self.content = content
+
+    def dump_content(self):
+        """ Return the stored content in yaml format. """
+        return ordered_yaml_dump(self.content)
+
+    def has_cluster(self, name):
+        """
+        Return true if this kubeconfig contains an entry
+        For the passed cluster name.
+        """
+        if self.content.get('clusters') is None:
+            return False
+        return name in [cluster['name']
+                        for cluster in self.content['clusters'] if 'name' in cluster]
+
+    def __eq__(self, other):
+        return (
+            isinstance(other, Kubeconfig)
+            and self.path == other.path
+            and self.content == other.content
+        )
+
+
+class KubeconfigValidator(object):
+    def __init__(self):
+        # Validation_content is an empty Kubeconfig
+        # It is used as a way to know what types different entries should be
+        self._validation_content = Kubeconfig(None, None).content
+
+    def validate_config(self, config):
+        """
+        Raises KubeconfigCorruptedError if the passed content is invalid
+
+        :param config: The config to validate
+        :type config: Kubeconfig
+        """
+        if not isinstance(config, Kubeconfig):
+            raise KubeconfigCorruptedError("Internal error: "
+                                           f"Not a {Kubeconfig}.")
+        self._validate_config_types(config)
+        self._validate_list_entry_types(config)
+
+    def _validate_config_types(self, config):
+        """
+        Raises KubeconfigCorruptedError if any of the entries in config
+        are the wrong type
+
+        :param config: The config to validate
+        :type config: Kubeconfig
+        """
+        if not isinstance(config.content, dict):
+            raise KubeconfigCorruptedError(f"Content not a {dict}.")
+        for key, value in self._validation_content.items():
+            if (key in config.content and
+                    config.content[key] is not None and
+                    not isinstance(config.content[key], type(value))):
+                raise KubeconfigCorruptedError(
+                    f"{key} is wrong type: {type(config.content[key])} "
+                    f"(Should be {type(value)})"
+                )
+
+    def _validate_list_entry_types(self, config):
+        """
+        Raises KubeconfigCorruptedError if any lists in config contain objects
+        which are not dictionaries
+
+        :param config: The config to validate
+        :type config: Kubeconfig
+        """
+        for key, value in self._validation_content.items():
+            if (key in config.content and
+                    type(config.content[key]) == list):
+                for element in config.content[key]:
+                    if not isinstance(element, OrderedDict):
+                        raise KubeconfigCorruptedError(
+                            f"Entry in {key} not a {dict}. ")
+
+
+class KubeconfigLoader(object):
+    def __init__(self, validator = None):
+        if validator is None:
+            validator=KubeconfigValidator()
+        self._validator=validator
+
+    def load_kubeconfig(self, path):
+        """
+        Loads the kubeconfig found at the given path.
+        If no file is found at the given path,
+        Generate a new kubeconfig to write back.
+        If the kubeconfig is valid, loads the content from it.
+        If the kubeconfig is invalid, throw the relevant exception.
+
+        :param path: The path to load a kubeconfig from
+        :type path: string
+
+        :raises KubeconfigInaccessableError: if the kubeconfig can't be opened
+        :raises KubeconfigCorruptedError: if the kubeconfig is invalid
+
+        :return: The loaded kubeconfig
+        :rtype: Kubeconfig
+        """
+        try:
+            with open(path, "r") as stream:
+                loaded_content=ordered_yaml_load(stream)
+        except IOError as e:
+            if e.errno == errno.ENOENT:
+                loaded_content=None
+            else:
+                raise KubeconfigInaccessableError(
+                    f"Can't open kubeconfig for reading: {e}")
+        except yaml.YAMLError as e:
+            raise KubeconfigCorruptedError(
+                f"YamlError while loading kubeconfig: {e}")
+
+        loaded_config=Kubeconfig(path, loaded_content)
+        self._validator.validate_config(loaded_config)
+
+        return loaded_config
+
+
+class KubeconfigWriter(object):
+    def write_kubeconfig(self, config):
+        """
+        Write config to disk.
+        OK if the file doesn't exist.
+
+        :param config: The kubeconfig to write
+        :type config: Kubeconfig
+
+        :raises KubeconfigInaccessableError: if the kubeconfig
+        can't be opened for writing
+        """
+        directory=os.path.dirname(config.path)
+
+        try:
+            os.makedirs(directory)
+        except OSError as e:
+            if e.errno != errno.EEXIST:
+                raise KubeconfigInaccessableError(
+                    f"Can't create directory for writing: {e}")
+        try:
+            with os.fdopen(
+                    os.open(
+                        config.path,
+                        os.O_CREAT | os.O_RDWR | os.O_TRUNC,
+                        0o600),
+                    "w+") as stream:
+                ordered_yaml_dump(config.content, stream)
+        except (IOError, OSError) as e:
+            raise KubeconfigInaccessableError(
+                f"Can't open kubeconfig for writing: {e}")
+
+
+class KubeconfigAppender(object):
+    def insert_entry(self, config, key, new_entry):
+        """
+        Insert entry into the entries list at content[key]
+        Overwrite an existing entry if they share the same name
+
+        :param config: The kubeconfig to insert an entry into
+        :type config: Kubeconfig
+        """
+        entries=self._setdefault_existing_entries(config, key)
+        same_name_index=self._index_same_name(entries, new_entry)
+        if same_name_index is None:
+            entries.append(new_entry)
+        else:
+            entries[same_name_index]=new_entry
+        return config
+
+    def _setdefault_existing_entries(self, config, key):
+        config.content[key]=config.content.get(key) or []
+        entries=config.content[key]
+        if not isinstance(entries, list):
+            raise KubeconfigError(f"Tried to insert into {key}, "
+                                  f"which is a {type(entries)} "
+                                  f"not a {list}")
+        return entries
+
+    def _index_same_name(self, entries, new_entry):
+        if "name" in new_entry:
+            name_to_search=new_entry["name"]
+            for i, entry in enumerate(entries):
+                if "name" in entry and entry["name"] == name_to_search:
+                    return i
+        return None
+
+    def _make_context(self, cluster, user, alias = None):
+        """ Generate a context to associate cluster and user with a given alias."""
+        return OrderedDict([
+            ("context", OrderedDict([
+                ("cluster", cluster["name"]),
+                ("user", user["name"])
+            ])),
+            ("name", alias or user["name"])
+        ])
+
+    def insert_cluster_user_pair(self, config, cluster, user, alias = None):
+        """
+        Insert the passed cluster entry and user entry,
+        then make a context to associate them
+        and set current-context to be the new context.
+        Returns the new context
+
+        :param config: the Kubeconfig to insert the pair into
+        :type config: Kubeconfig
+
+        :param cluster: the cluster entry
+        :type cluster: OrderedDict
+
+        :param user: the user entry
+        :type user: OrderedDict
+
+        :param alias: the alias for the context; defaults top user entry name
+        :type context: str
+
+        :return: The generated context
+        :rtype: OrderedDict
+        """
+        context=self._make_context(cluster, user, alias = alias)
+        self.insert_entry(config, "clusters", cluster)
+        self.insert_entry(config, "users", user)
+        self.insert_entry(config, "contexts", context)
+
+        config.content["current-context"]=context["name"]
+
+        return context

data/lib/python3.10/site-packages/awscli/customizations/eks/ordered_yaml.py

@@ -0,0 +1,62 @@
+# Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+# http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+import yaml
+from botocore.compat import OrderedDict
+
+
+class SafeOrderedLoader(yaml.SafeLoader):
+    """ Safely load a yaml file into an OrderedDict."""
+
+
+class SafeOrderedDumper(yaml.SafeDumper):
+    """ Safely dump an OrderedDict as yaml."""
+
+
+def _ordered_constructor(loader, node):
+        loader.flatten_mapping(node)
+        return OrderedDict(loader.construct_pairs(node))
+
+
+SafeOrderedLoader.add_constructor(
+                    yaml.resolver.BaseResolver.DEFAULT_MAPPING_TAG,
+                    _ordered_constructor)
+
+
+def _ordered_representer(dumper, data):
+        return dumper.represent_mapping(
+            yaml.resolver.BaseResolver.DEFAULT_MAPPING_TAG,
+            data.items())
+
+
+SafeOrderedDumper.add_representer(OrderedDict, _ordered_representer)
+
+
+def ordered_yaml_load(stream):
+    """ Load an OrderedDict object from a yaml stream."""
+    return yaml.load(stream, SafeOrderedLoader)
+
+
+def ordered_yaml_dump(to_dump, stream=None):
+    """
+    Dump an OrderedDict object to yaml.
+
+    :param to_dump: The OrderedDict to dump
+    :type to_dump: OrderedDict
+
+    :param stream: The file to dump to
+    If not given or if None, only return the value
+    :type stream: file
+    """
+    return yaml.dump(to_dump, stream,
+                     SafeOrderedDumper, default_flow_style=False)

data/lib/python3.10/site-packages/awscli/customizations/eks/update_kubeconfig.py

@@ -0,0 +1,341 @@
+# Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+# http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+import os
+import logging
+
+from botocore.compat import OrderedDict
+
+from awscli.customizations.commands import BasicCommand
+from awscli.customizations.utils import uni_print
+from awscli.customizations.eks.exceptions import EKSClusterError
+from awscli.customizations.eks.kubeconfig import (Kubeconfig,
+                                                  KubeconfigError,
+                                                  KubeconfigLoader,
+                                                  KubeconfigWriter,
+                                                  KubeconfigValidator,
+                                                  KubeconfigAppender)
+from awscli.customizations.eks.ordered_yaml import ordered_yaml_dump
+
+LOG = logging.getLogger(__name__)
+
+DEFAULT_PATH = os.path.expanduser("~/.kube/config")
+
+# At the time EKS no longer supports Kubernetes v1.21 (probably ~Dec 2023),
+# this can be safely changed to default to writing "v1"
+API_VERSION = "client.authentication.k8s.io/v1beta1"
+
+class UpdateKubeconfigCommand(BasicCommand):
+    NAME = 'update-kubeconfig'
+
+    DESCRIPTION = BasicCommand.FROM_FILE(
+        'eks',
+        'update-kubeconfig',
+        '_description.rst'
+    )
+
+    ARG_TABLE = [
+        {
+            'name': 'name',
+            'dest': 'cluster_name',
+            'help_text': ("The name of the cluster for which "
+                          "to create a kubeconfig entry. "
+                          "This cluster must exist in your account and in the "
+                          "specified or configured default Region "
+                          "for your AWS CLI installation."),
+            'required': True
+        },
+        {
+            'name': 'kubeconfig',
+            'help_text': ("Optionally specify a kubeconfig file to append "
+                          "with your configuration. "
+                          "By default, the configuration is written to the "
+                          "first file path in the KUBECONFIG "
+                          "environment variable (if it is set) "
+                          "or the default kubeconfig path (.kube/config) "
+                          "in your home directory."),
+            'required': False
+        },
+        {
+            'name': 'role-arn',
+            'help_text': ("To assume a role for cluster authentication, "
+                          "specify an IAM role ARN with this option. "
+                          "For example, if you created a cluster "
+                          "while assuming an IAM role, "
+                          "then you must also assume that role to "
+                          "connect to the cluster the first time."),
+            'required': False
+        },
+        {
+            'name': 'dry-run',
+            'action': 'store_true',
+            'default': False,
+            'help_text': ("Print the merged kubeconfig to stdout instead of "
+                          "writing it to the specified file."),
+            'required': False
+        },
+        {
+            'name': 'verbose',
+            'action': 'store_true',
+            'default': False,
+            'help_text': ("Print more detailed output "
+                          "when writing to the kubeconfig file, "
+                          "including the appended entries.")
+        },
+        {
+            'name': 'alias',
+            'help_text': ("Alias for the cluster context name. "
+                          "Defaults to match cluster ARN."),
+            'required': False
+        },
+        {
+            'name': 'user-alias',
+            'help_text': ("Alias for the generated user name. "
+                          "Defaults to match cluster ARN."),
+            'required': False
+        }
+    ]
+
+    def _display_entries(self, entries):
+        """
+        Display entries in yaml format
+
+        :param entries: a list of OrderedDicts to be printed
+        :type entries: list
+        """
+        uni_print("Entries:\n\n")
+        for entry in entries:
+            uni_print(ordered_yaml_dump(entry))
+            uni_print("\n")
+
+    def _run_main(self, parsed_args, parsed_globals):
+        client = EKSClient(self._session,
+                           parsed_args=parsed_args,
+                           parsed_globals=parsed_globals)
+        new_cluster_dict = client.get_cluster_entry()
+        new_user_dict = client.get_user_entry(user_alias=parsed_args.user_alias)
+
+        config_selector = KubeconfigSelector(
+            os.environ.get("KUBECONFIG", ""),
+            parsed_args.kubeconfig
+        )
+        config = config_selector.choose_kubeconfig(
+            new_cluster_dict["name"]
+        )
+        updating_existing = config.has_cluster(new_cluster_dict["name"])
+        appender = KubeconfigAppender()
+        new_context_dict = appender.insert_cluster_user_pair(config,
+                                                             new_cluster_dict,
+                                                             new_user_dict,
+                                                             parsed_args.alias)
+
+        if parsed_args.dry_run:
+            uni_print(config.dump_content())
+        else:
+            writer = KubeconfigWriter()
+            writer.write_kubeconfig(config)
+
+            if updating_existing:
+                uni_print("Updated context {0} in {1}\n".format(
+                    new_context_dict["name"], config.path
+                ))
+            else:
+                uni_print("Added new context {0} to {1}\n".format(
+                    new_context_dict["name"], config.path
+                ))
+
+            if parsed_args.verbose:
+                self._display_entries([
+                    new_context_dict,
+                    new_user_dict,
+                    new_cluster_dict
+                ])
+
+
+
+class KubeconfigSelector(object):
+
+    def __init__(self, env_variable, path_in, validator=None,
+                                              loader=None):
+        """
+        Parse KUBECONFIG into a list of absolute paths.
+        Also replace the empty list with DEFAULT_PATH
+
+        :param env_variable: KUBECONFIG as a long string
+        :type env_variable: string
+
+        :param path_in: The path passed in through the CLI
+        :type path_in: string or None
+        """
+        if validator is None:
+            validator = KubeconfigValidator()
+        self._validator = validator
+
+        if loader is None:
+            loader = KubeconfigLoader(validator)
+        self._loader = loader
+
+        if path_in is not None:
+            # Override environment variable
+            self._paths = [self._expand_path(path_in)]
+        else:
+            # Get the list of paths from the environment variable
+            if env_variable == "":
+                env_variable = DEFAULT_PATH
+            self._paths = [self._expand_path(element)
+                           for element in env_variable.split(os.pathsep)
+                           if len(element.strip()) > 0]
+            if len(self._paths) == 0:
+                self._paths = [DEFAULT_PATH]
+
+    def choose_kubeconfig(self, cluster_name):
+        """
+        Choose which kubeconfig file to read from.
+        If name is already an entry in one of the $KUBECONFIG files,
+        choose that one.
+        Otherwise choose the first file.
+
+        :param cluster_name: The name of the cluster which is going to be added
+        :type cluster_name: String
+
+        :return: a chosen Kubeconfig based on above rules
+        :rtype: Kubeconfig
+        """
+        # Search for an existing entry to update
+        for candidate_path in self._paths:
+            try:
+                loaded_config = self._loader.load_kubeconfig(candidate_path)
+
+                if loaded_config.has_cluster(cluster_name):
+                    LOG.debug("Found entry to update at {0}".format(
+                        candidate_path
+                    ))
+                    return loaded_config
+            except KubeconfigError as e:
+                LOG.warning("Passing {0}:{1}".format(candidate_path, e))
+
+        # No entry was found, use the first file in KUBECONFIG
+        #
+        # Note: This could raise KubeconfigErrors if paths[0] is corrupted
+        return self._loader.load_kubeconfig(self._paths[0])
+
+    def _expand_path(self, path):
+        """ A helper to expand a path to a full absolute path. """
+        return os.path.abspath(os.path.expanduser(path))
+
+
+class EKSClient(object):
+    def __init__(self, session, parsed_args, parsed_globals=None):
+        self._session = session
+        self._cluster_name = parsed_args.cluster_name
+        self._cluster_description = None
+        self._parsed_globals = parsed_globals
+        self._parsed_args = parsed_args
+
+    @property
+    def cluster_description(self):
+        """
+        Use an eks describe-cluster call to get the cluster description
+        Cache the response in self._cluster_description.
+        describe-cluster will only be called once.
+        """
+        if self._cluster_description is None:
+            if self._parsed_globals is None:
+                client = self._session.create_client("eks")
+            else:
+                client = self._session.create_client(
+                    "eks",
+                    region_name=self._parsed_globals.region,
+                    endpoint_url=self._parsed_globals.endpoint_url,
+                    verify=self._parsed_globals.verify_ssl
+                )
+            full_description = client.describe_cluster(name=self._cluster_name)
+            self._cluster_description = full_description["cluster"]
+
+            if "status" not in self._cluster_description:
+                raise EKSClusterError("Cluster not found")
+            if self._cluster_description["status"] not in ["ACTIVE", "UPDATING"]:
+                raise EKSClusterError("Cluster status is {0}".format(
+                    self._cluster_description["status"]
+                ))
+
+        return self._cluster_description
+
+    def get_cluster_entry(self):
+        """
+        Return a cluster entry generated using
+        the previously obtained description.
+        """
+
+        cert_data = self.cluster_description.get("certificateAuthority", {}).get("data", "")
+        endpoint = self.cluster_description.get("endpoint")
+        arn = self.cluster_description.get("arn")
+
+        return OrderedDict([
+            ("cluster", OrderedDict([
+                ("certificate-authority-data", cert_data),
+                ("server", endpoint)
+            ])),
+            ("name", arn)
+        ])
+
+    def get_user_entry(self, user_alias=None):
+        """
+        Return a user entry generated using
+        the previously obtained description.
+        """
+        region = self.cluster_description.get("arn").split(":")[3]
+        outpost_config = self.cluster_description.get("outpostConfig")
+
+        if outpost_config is None:
+            cluster_identification_parameter = "--cluster-name"
+            cluster_identification_value = self._cluster_name
+        else:
+            # If cluster contains outpostConfig, use id for identification
+            cluster_identification_parameter = "--cluster-id"
+            cluster_identification_value = self.cluster_description.get("id")
+
+        generated_user = OrderedDict([
+            ("name", user_alias or self.cluster_description.get("arn", "")),
+            ("user", OrderedDict([
+                ("exec", OrderedDict([
+                    ("apiVersion", API_VERSION),
+                    ("args",
+                        [
+                            "--region",
+                            region,
+                            "eks",
+                            "get-token",
+                            cluster_identification_parameter,
+                            cluster_identification_value,
+                            "--output",
+                            "json",
+                        ]),
+                    ("command", "aws"),
+                ]))
+            ]))
+        ])
+
+        if self._parsed_args.role_arn is not None:
+            generated_user["user"]["exec"]["args"].extend([
+                "--role",
+                self._parsed_args.role_arn
+            ])
+
+        if self._session.profile:
+            generated_user["user"]["exec"]["env"] = [OrderedDict([
+                ("name", "AWS_PROFILE"),
+                ("value", self._session.profile)
+            ])]
+
+        return generated_user