ansible-core 2.18.5rc1__py3-none-any.whl → 2.19.0b2__py3-none-any.whl

ansible/plugins/lookup/password.py

@@ -160,7 +160,7 @@ def _read_password_file(b_path):
 
 
 def _gen_candidate_chars(characters):
-    '''Generate a string containing all valid chars as defined by ``characters``
+    """Generate a string containing all valid chars as defined by ``characters``
 
     :arg characters: A list of character specs. The character specs are
         shorthand names for sets of characters like 'digits', 'ascii_letters',
@@ -181,7 +181,7 @@ def _gen_candidate_chars(characters):
     the question mark and pipe characters directly. Return will be the string::
 
         u'0123456789?|'
-    '''
+    """
     chars = []
     for chars_spec in characters:
         # getattr from string expands things like "ascii_letters" and "digits"
@@ -192,11 +192,11 @@ def _gen_candidate_chars(characters):
 
 
 def _parse_content(content):
-    '''parse our password data format into password and salt
+    """parse our password data format into password and salt
 
     :arg content: The data read from the file
     :returns: password and salt
-    '''
+    """
     password = content
     salt = None
     ident = None
@@ -350,7 +350,7 @@ class LookupModule(LookupBase):
 
         return relpath, params
 
-    def run(self, terms, variables, **kwargs):
+    def run(self, terms, variables=None, **kwargs):
         ret = []
 
         for term in terms:

ansible/plugins/lookup/pipe.py

@@ -15,14 +15,12 @@ DOCUMENTATION = r"""
         description: command(s) to run.
         required: True
     notes:
+      - The given command is passed to a shell for execution, therefore all variables that are part of the command and
+        come from a remote/untrusted source MUST be sanitized using the P(ansible.builtin.quote#filter) filter to avoid
+        shell injection vulnerabilities. See the example section.
       - Like all lookups this runs on the Ansible controller and is unaffected by other keywords, such as become,
         so if you need to different permissions you must change the command or run Ansible as another user.
       - Alternatively you can use a shell/command task that runs against localhost and registers the result.
-      - Pipe lookup internally invokes Popen with shell=True (this is required and intentional).
-        This type of invocation is considered a security issue if appropriate care is not taken to sanitize any user provided or variable input.
-        It is strongly recommended to pass user input or variable input via quote filter before using with pipe lookup.
-        See example section for this.
-        Read more about this L(Bandit B602 docs,https://bandit.readthedocs.io/en/latest/plugins/b602_subprocess_popen_with_shell_equals_true.html)
       - The directory of the play is used as the current working directory.
 """
 
@@ -52,7 +50,7 @@ from ansible.plugins.lookup import LookupBase
 
 class LookupModule(LookupBase):
 
-    def run(self, terms, variables, **kwargs):
+    def run(self, terms, variables=None, **kwargs):
 
         ret = []
         for term in terms:
@@ -65,7 +63,7 @@ class LookupModule(LookupBase):
             # https://github.com/ansible/ansible/issues/6550
             term = str(term)
 
-            p = subprocess.Popen(term, cwd=self._loader.get_basedir(), shell=True, stdin=subprocess.PIPE, stdout=subprocess.PIPE)
+            p = subprocess.Popen(term, cwd=self._templar.basedir, shell=True, stdin=subprocess.PIPE, stdout=subprocess.PIPE)
             (stdout, stderr) = p.communicate()
             if p.returncode == 0:
                 ret.append(stdout.decode("utf-8").rstrip())

ansible/plugins/lookup/sequence.py

@@ -171,6 +171,12 @@ class LookupModule(LookupBase):
             setattr(self, f, self.get_option(f))
 
     def sanity_check(self):
+        """
+        Returns True if options comprise a valid sequence expression
+        Raises AnsibleError if options are an invalid expression
+        Returns false if options are valid but result in an empty sequence - these cases do not raise exceptions
+        in order to maintain historic behavior
+        """
         if self.count is None and self.end is None:
             raise AnsibleError("must specify count or end in with_sequence")
         elif self.count is not None and self.end is not None:
@@ -180,17 +186,18 @@ class LookupModule(LookupBase):
             if self.count != 0:
                 self.end = self.start + self.count * self.stride - 1
             else:
-                self.start = 0
-                self.end = 0
-                self.stride = 0
-            del self.count
+                return False
         if self.stride > 0 and self.end < self.start:
             raise AnsibleError("to count backwards make stride negative")
         if self.stride < 0 and self.end > self.start:
             raise AnsibleError("to count forward don't make stride negative")
+        if self.stride == 0:
+            return False
         if self.format.count('%') != 1:
             raise AnsibleError("bad formatting string: %s" % self.format)
 
+        return True
+
     def generate_sequence(self):
         if self.stride >= 0:
             adjust = 1
@@ -207,9 +214,13 @@ class LookupModule(LookupBase):
                     "problem formatting %r with %r" % (i, self.format)
                 )
 
-    def run(self, terms, variables, **kwargs):
+    def run(self, terms, variables=None, **kwargs):
         results = []
 
+        if kwargs and not terms:
+            # All of the necessary arguments can be provided as keywords, but we still need something to loop over
+            terms = ['']
+
         for term in terms:
             try:
                 # set defaults/global
@@ -223,10 +234,9 @@ class LookupModule(LookupBase):
                     raise AnsibleError("unknown error parsing with_sequence arguments: %r. Error was: %s" % (term, e))
 
                 self.set_fields()
-                self.sanity_check()
-
-                if self.stride != 0:
+                if self.sanity_check():
                     results.extend(self.generate_sequence())
+
             except AnsibleError:
                 raise
             except Exception as e:

ansible/plugins/lookup/subelements.py

@@ -86,7 +86,6 @@ from ansible.errors import AnsibleError
 from ansible.module_utils.six import string_types
 from ansible.module_utils.parsing.convert_bool import boolean
 from ansible.plugins.lookup import LookupBase
-from ansible.utils.listify import listify_lookup_plugin_terms
 
 
 FLAGS = ('skip_missing',)
@@ -94,14 +93,12 @@ FLAGS = ('skip_missing',)
 
 class LookupModule(LookupBase):
 
-    def run(self, terms, variables, **kwargs):
+    def run(self, terms, variables=None, **kwargs):
 
         def _raise_terms_error(msg=""):
             raise AnsibleError(
                 "subelements lookup expects a list of two or three items, " + msg)
 
-        terms[0] = listify_lookup_plugin_terms(terms[0], templar=self._templar)
-
         # check lookup terms - check number of terms
         if not isinstance(terms, list) or not 2 <= len(terms) <= 3:
             _raise_terms_error()

ansible/plugins/lookup/template.py

@@ -17,9 +17,13 @@ DOCUMENTATION = """
       convert_data:
         type: bool
         description:
-            - Whether to convert YAML into data. If False, strings that are YAML will be left untouched.
-            - Mutually exclusive with the jinja2_native option.
+            - Whether to convert YAML into data. If V(False), strings that are YAML will be left untouched.
+            - Mutually exclusive with the O(jinja2_native) option.
         default: true
+        deprecated:
+          why: This option is no longer used in the Ansible Core code base.
+          version: "2.21"
+          alternatives: Jinja2 native mode is now the default and only option, which is mutually exclusive with this option.
       variable_start_string:
         description: The string marking the beginning of a print statement.
         default: '{{'
@@ -33,13 +37,16 @@ DOCUMENTATION = """
       jinja2_native:
         description:
             - Controls whether to use Jinja2 native types.
-            - It is off by default even if global jinja2_native is True.
-            - Has no effect if global jinja2_native is False.
+            - It is off by default even if global O(jinja2_native) is V(True).
+            - Has no effect if global O(jinja2_native) is V(False).
             - This offers more flexibility than the template module which does not use Jinja2 native types at all.
-            - Mutually exclusive with the convert_data option.
-        default: False
+        default: True
         version_added: '2.11'
         type: bool
+        deprecated:
+          why: This option is no longer used in the Ansible Core code base.
+          version: "2.21"
+          alternatives: Jinja2 native mode is now the default and only option.
       template_vars:
         description: A dictionary, the keys become additional variables available for templating.
         default: {}
@@ -55,6 +62,13 @@ DOCUMENTATION = """
         version_added: '2.12'
         type: str
         default: '#}'
+      trim_blocks:
+        description:
+        - Determine when newlines should be removed from blocks.
+        - When set to V(yes) the first newline after a block is removed (block, not variable tag!).
+        type: bool
+        default: yes
+        version_added: '2.19'
     seealso:
       - ref: playbook_task_paths
         description: Search paths used for relative templates.
@@ -72,6 +86,11 @@ EXAMPLES = """
 - name: show templating results with different comment start and end string
   ansible.builtin.debug:
     msg: "{{ lookup('ansible.builtin.template', './some_template.j2', comment_start_string='[#', comment_end_string='#]') }}"
+
+- name: show templating results with trim_blocks
+  ansible.builtin.debug:
+    msg: "{{ lookup('ansible.builtin.template', './some_template.j2', trim_blocks=True) }}"
+
 """
 
 RETURN = """
@@ -84,14 +103,10 @@ _raw:
 from copy import deepcopy
 import os
 
-import ansible.constants as C
-
 from ansible.errors import AnsibleError
 from ansible.plugins.lookup import LookupBase
-from ansible.module_utils.common.text.converters import to_text
-from ansible.template import generate_ansible_template_vars, AnsibleEnvironment
+from ansible.template import generate_ansible_template_vars, trust_as_template
 from ansible.utils.display import Display
-from ansible.utils.native_jinja import NativeJinjaText
 
 
 display = Display()
@@ -99,25 +114,21 @@ display = Display()
 
 class LookupModule(LookupBase):
 
-    def run(self, terms, variables, **kwargs):
+    def run(self, terms, variables=None, **kwargs):
 
         ret = []
 
         self.set_options(var_options=variables, direct=kwargs)
 
         # capture options
-        convert_data_p = self.get_option('convert_data')
         lookup_template_vars = self.get_option('template_vars')
-        jinja2_native = self.get_option('jinja2_native') and C.DEFAULT_JINJA2_NATIVE
         variable_start_string = self.get_option('variable_start_string')
         variable_end_string = self.get_option('variable_end_string')
         comment_start_string = self.get_option('comment_start_string')
         comment_end_string = self.get_option('comment_end_string')
+        trim_blocks = self.get_option('trim_blocks')
 
-        if jinja2_native:
-            templar = self._templar
-        else:
-            templar = self._templar.copy_with_new_env(environment_class=AnsibleEnvironment)
+        templar = self._templar
 
         for term in terms:
             display.debug("File lookup term: %s" % term)
@@ -125,8 +136,7 @@ class LookupModule(LookupBase):
             lookupfile = self.find_file_in_search_path(variables, 'templates', term)
             display.vvvv("File lookup using %s as file" % lookupfile)
             if lookupfile:
-                b_template_data, show_data = self._loader._get_file_contents(lookupfile)
-                template_data = to_text(b_template_data, errors='surrogate_or_strict')
+                template_data = trust_as_template(self._loader.get_text_file_contents(lookupfile))
 
                 # set jinja2 internal search path for includes
                 searchpath = variables.get('ansible_search_path', [])
@@ -145,25 +155,21 @@ class LookupModule(LookupBase):
                 # plus some added by ansible (e.g., template_{path,mtime}),
                 # plus anything passed to the lookup with the template_vars=
                 # argument.
+                # FIXME: why isn't this a chainmap with a sacrificial bottom layer?
                 vars = deepcopy(variables)
-                vars.update(generate_ansible_template_vars(term, lookupfile))
+                vars.update(generate_ansible_template_vars(term, fullpath=lookupfile))
                 vars.update(lookup_template_vars)
 
-                with templar.set_temporary_context(available_variables=vars, searchpath=searchpath):
-                    overrides = dict(
-                        variable_start_string=variable_start_string,
-                        variable_end_string=variable_end_string,
-                        comment_start_string=comment_start_string,
-                        comment_end_string=comment_end_string
-                    )
-                    res = templar.template(template_data, preserve_trailing_newlines=True,
-                                           convert_data=convert_data_p, escape_backslashes=False,
-                                           overrides=overrides)
-
-                if (C.DEFAULT_JINJA2_NATIVE and not jinja2_native) or not convert_data_p:
-                    # jinja2_native is true globally but off for the lookup, we need this text
-                    # not to be processed by literal_eval anywhere in Ansible
-                    res = NativeJinjaText(res)
+                overrides = dict(
+                    variable_start_string=variable_start_string,
+                    variable_end_string=variable_end_string,
+                    comment_start_string=comment_start_string,
+                    comment_end_string=comment_end_string,
+                    trim_blocks=trim_blocks,
+                )
+
+                data_templar = templar.copy_with_new_env(available_variables=vars, searchpath=searchpath)
+                res = data_templar.template(template_data, escape_backslashes=False, overrides=overrides)
 
                 ret.append(res)
             else:

ansible/plugins/lookup/together.py

@@ -38,7 +38,6 @@ import itertools
 
 from ansible.errors import AnsibleError
 from ansible.plugins.lookup import LookupBase
-from ansible.utils.listify import listify_lookup_plugin_terms
 
 
 class LookupModule(LookupBase):
@@ -48,18 +47,7 @@ class LookupModule(LookupBase):
     Replace any empty spots in 2nd array with None:
     [1, 2], [3] -> [1, 3], [2, None]
     """
-
-    def _lookup_variables(self, terms):
-        results = []
-        for x in terms:
-            intermediate = listify_lookup_plugin_terms(x, templar=self._templar)
-            results.append(intermediate)
-        return results
-
     def run(self, terms, variables=None, **kwargs):
-
-        terms = self._lookup_variables(terms)
-
         my_list = terms[:]
         if len(my_list) == 0:
             raise AnsibleError("with_together requires at least one element in each list")

ansible/plugins/lookup/unvault.py

@@ -34,7 +34,6 @@ RETURN = """
 
 from ansible.errors import AnsibleParserError
 from ansible.plugins.lookup import LookupBase
-from ansible.module_utils.common.text.converters import to_text
 from ansible.utils.display import Display
 
 display = Display()
@@ -55,10 +54,7 @@ class LookupModule(LookupBase):
             lookupfile = self.find_file_in_search_path(variables, 'files', term)
             display.vvvv(u"Unvault lookup found %s" % lookupfile)
             if lookupfile:
-                actual_file = self._loader.get_real_file(lookupfile, decrypt=True)
-                with open(actual_file, 'rb') as f:
-                    b_contents = f.read()
-                ret.append(to_text(b_contents))
+                ret.append(self._loader.get_text_file_contents(lookupfile))
             else:
                 raise AnsibleParserError('Unable to find file matching "%s" ' % term)
 

ansible/plugins/lookup/url.py

@@ -87,7 +87,6 @@ options:
         - section: url_lookup
           key: force_basic_auth
   follow_redirects:
-    description: String of urllib2, all/yes, safe, none to determine how redirects are followed
     type: string
     version_added: "2.10"
     default: 'urllib2'
@@ -98,13 +97,6 @@ options:
     ini:
         - section: url_lookup
           key: follow_redirects
-    choices:
-      all: Will follow all redirects.
-      none: Will not follow any redirects.
-      safe: Only redirects doing GET or HEAD requests will be followed.
-      urllib2: Defer to urllib2 behavior (As of writing this follows HTTP redirects).
-      'no': (DEPRECATED, removed in 2.22) alias of V(none).
-      'yes': (DEPRECATED, removed in 2.22) alias of V(all).
   use_gssapi:
     description:
     - Use GSSAPI handler of requests
@@ -185,6 +177,8 @@ options:
     ini:
         - section: url_lookup
           key: ciphers
+extends_documentation_fragment:
+  - url.url_redirect
 """
 
 EXAMPLES = """

ansible/plugins/lookup/vars.py

@@ -73,40 +73,32 @@ _value:
   elements: raw
 """
 
-from ansible.errors import AnsibleError, AnsibleUndefinedVariable
-from ansible.module_utils.six import string_types
+from ansible.errors import AnsibleTypeError
 from ansible.plugins.lookup import LookupBase
+from ansible.module_utils.datatag import native_type_name
+from ansible._internal._templating import _jinja_bits
 
 
 class LookupModule(LookupBase):
-
-    def run(self, terms, variables=None, **kwargs):
-        if variables is not None:
-            self._templar.available_variables = variables
-        myvars = getattr(self._templar, '_available_variables', {})
-
+    def run(self, terms, variables, **kwargs):
         self.set_options(var_options=variables, direct=kwargs)
+
         default = self.get_option('default')
 
         ret = []
+
         for term in terms:
-            if not isinstance(term, string_types):
-                raise AnsibleError('Invalid setting identifier, "%s" is not a string, its a %s' % (term, type(term)))
+            if not isinstance(term, str):
+                raise AnsibleTypeError(f'Variable name must be {native_type_name(str)!r} not {native_type_name(term)!r}.', obj=term)
 
             try:
-                try:
-                    value = myvars[term]
-                except KeyError:
-                    try:
-                        value = myvars['hostvars'][myvars['inventory_hostname']][term]
-                    except KeyError:
-                        raise AnsibleUndefinedVariable('No variable found with this name: %s' % term)
-
-                ret.append(self._templar.template(value, fail_on_undefined=True))
-            except AnsibleUndefinedVariable:
-                if default is not None:
-                    ret.append(default)
+                value = variables[term]
+            except KeyError:
+                if default is None:
+                    value = _jinja_bits._undef(f'No variable named {term!r} was found.')
                 else:
-                    raise
+                    value = default
+
+            ret.append(value)
 
-        return ret
+        return self._templar._engine.template(ret)

ansible/plugins/shell/__init__.py

@@ -164,7 +164,7 @@ class ShellBase(AnsiblePlugin):
         return cmd
 
     def expand_user(self, user_home_path, username=''):
-        ''' Return a command to expand tildes in a path
+        """ Return a command to expand tildes in a path
 
         It can be either "~" or "~username". We just ignore $HOME
         We use the POSIX definition of a username:
@@ -172,7 +172,7 @@ class ShellBase(AnsiblePlugin):
             http://pubs.opengroup.org/onlinepubs/000095399/basedefs/xbd_chap03.html#tag_03_276
 
             Falls back to 'current working directory' as we assume 'home is where the remote user ends up'
-        '''
+        """
 
         # Check that the user_path to expand is safe
         if user_home_path != '~':

ansible/plugins/shell/cmd.py

@@ -2,7 +2,7 @@
 # GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
 from __future__ import annotations
 
-DOCUMENTATION = '''
+DOCUMENTATION = """
 name: cmd
 version_added: '2.8'
 short_description: Windows Command Prompt
@@ -10,7 +10,7 @@ description:
 - Used with the 'ssh' connection plugin and no C(DefaultShell) has been set on the Windows host.
 extends_documentation_fragment:
 - shell_windows
-'''
+"""
 
 import re
 

ansible/plugins/shell/powershell.py

@@ -3,7 +3,7 @@
 # GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
 from __future__ import annotations
 
-DOCUMENTATION = '''
+DOCUMENTATION = """
 name: powershell
 version_added: historical
 short_description: Windows PowerShell
@@ -12,16 +12,16 @@ description:
 - Can also be used when using 'ssh' as a connection plugin and the C(DefaultShell) has been configured to PowerShell.
 extends_documentation_fragment:
 - shell_windows
-'''
+"""
 
 import base64
 import os
 import re
 import shlex
-import pkgutil
 import xml.etree.ElementTree as ET
 import ntpath
 
+from ansible.executor.powershell.module_manifest import _get_powershell_script
 from ansible.module_utils.common.text.converters import to_bytes, to_text
 from ansible.plugins.shell import ShellBase
 
@@ -221,9 +221,9 @@ class ShellModule(ShellBase):
     def remove(self, path, recurse=False):
         path = self._escape(self._unquote(path))
         if recurse:
-            return self._encode_script('''Remove-Item '%s' -Force -Recurse;''' % path)
+            return self._encode_script("""Remove-Item '%s' -Force -Recurse;""" % path)
         else:
-            return self._encode_script('''Remove-Item '%s' -Force;''' % path)
+            return self._encode_script("""Remove-Item '%s' -Force;""" % path)
 
     def mkdtemp(self, basefile=None, system=False, mode=None, tmpdir=None):
         # Windows does not have an equivalent for the system temp files, so
@@ -233,12 +233,12 @@ class ShellModule(ShellBase):
         basefile = self._escape(self._unquote(basefile))
         basetmpdir = self._escape(tmpdir if tmpdir else self.get_option('remote_tmp'))
 
-        script = f'''
+        script = f"""
         {self._CONSOLE_ENCODING}
         $tmp_path = [System.Environment]::ExpandEnvironmentVariables('{basetmpdir}')
         $tmp = New-Item -Type Directory -Path $tmp_path -Name '{basefile}'
         Write-Output -InputObject $tmp.FullName
-        '''
+        """
         return self._encode_script(script.strip())
 
     def expand_user(self, user_home_path, username=''):
@@ -256,7 +256,7 @@ class ShellModule(ShellBase):
 
     def exists(self, path):
         path = self._escape(self._unquote(path))
-        script = '''
+        script = """
             If (Test-Path '%s')
             {
                 $res = 0;
@@ -267,12 +267,12 @@ class ShellModule(ShellBase):
             }
             Write-Output '$res';
             Exit $res;
-         ''' % path
+         """ % path
         return self._encode_script(script)
 
     def checksum(self, path, *args, **kwargs):
         path = self._escape(self._unquote(path))
-        script = '''
+        script = """
             If (Test-Path -PathType Leaf '%(path)s')
             {
                 $sp = new-object -TypeName System.Security.Cryptography.SHA1CryptoServiceProvider;
@@ -288,11 +288,11 @@ class ShellModule(ShellBase):
             {
                 Write-Output "1";
             }
-        ''' % dict(path=path)
+        """ % dict(path=path)
         return self._encode_script(script)
 
     def build_module_command(self, env_string, shebang, cmd, arg_path=None):
-        bootstrap_wrapper = pkgutil.get_data("ansible.executor.powershell", "bootstrap_wrapper.ps1")
+        bootstrap_wrapper = _get_powershell_script("bootstrap_wrapper.ps1")
 
         # pipelining bypass
         if cmd == '':
@@ -303,18 +303,35 @@ class ShellModule(ShellBase):
         cmd_parts = shlex.split(cmd, posix=False)
         cmd_parts = list(map(to_text, cmd_parts))
         if shebang and shebang.lower() == '#!powershell':
-            if not self._unquote(cmd_parts[0]).lower().endswith('.ps1'):
-                # we're running a module via the bootstrap wrapper
-                cmd_parts[0] = '"%s.ps1"' % self._unquote(cmd_parts[0])
-            wrapper_cmd = "type " + cmd_parts[0] + " | " + self._encode_script(script=bootstrap_wrapper, strict_mode=False, preserve_rc=False)
-            return wrapper_cmd
+            if arg_path:
+                # Running a module without the exec_wrapper and with an argument
+                # file.
+                script_path = self._unquote(cmd_parts[0])
+                if not script_path.lower().endswith('.ps1'):
+                    script_path += '.ps1'
+
+                cmd_parts.insert(0, '-File')
+                cmd_parts[1] = f'"{script_path}"'
+                if arg_path:
+                    cmd_parts.append(f'"{arg_path}"')
+
+                wrapper_cmd = " ".join(_common_args + cmd_parts)
+                return wrapper_cmd
+
+            else:
+                # Running a module with ANSIBLE_KEEP_REMOTE_FILES=true, the script
+                # arg is actually the input manifest JSON to provide to the bootstrap
+                # wrapper.
+                wrapper_cmd = "type " + cmd_parts[0] + " | " + self._encode_script(script=bootstrap_wrapper, strict_mode=False, preserve_rc=False)
+                return wrapper_cmd
+
         elif shebang and shebang.startswith('#!'):
             cmd_parts.insert(0, shebang[2:])
         elif not shebang:
             # The module is assumed to be a binary
             cmd_parts[0] = self._unquote(cmd_parts[0])
             cmd_parts.append(arg_path)
-        script = '''
+        script = """
             Try
             {
                 %s
@@ -349,14 +366,14 @@ class ShellModule(ShellBase):
                 Echo $_obj | ConvertTo-Json -Compress -Depth 99
                 Exit 1
             }
-        ''' % (env_string, ' '.join(cmd_parts))
+        """ % (env_string, ' '.join(cmd_parts))
         return self._encode_script(script, preserve_rc=False)
 
     def wrap_for_exec(self, cmd):
         return '& %s; exit $LASTEXITCODE' % cmd
 
     def _unquote(self, value):
-        '''Remove any matching quotes that wrap the given value.'''
+        """Remove any matching quotes that wrap the given value."""
         value = to_text(value or '')
         m = re.match(r'^\s*?\'(.*?)\'\s*?$', value)
         if m:
@@ -367,13 +384,13 @@ class ShellModule(ShellBase):
         return value
 
     def _escape(self, value):
-        '''Return value escaped for use in PowerShell single quotes.'''
+        """Return value escaped for use in PowerShell single quotes."""
         # There are 5 chars that need to be escaped in a single quote.
         # https://github.com/PowerShell/PowerShell/blob/b7cb335f03fe2992d0cbd61699de9d9aafa1d7c1/src/System.Management.Automation/engine/parser/CharTraits.cs#L265-L272
         return re.compile(u"(['\u2018\u2019\u201a\u201b])").sub(u'\\1\\1', value)
 
     def _encode_script(self, script, as_list=False, strict_mode=True, preserve_rc=True):
-        '''Convert a PowerShell script to a single base64-encoded command.'''
+        """Convert a PowerShell script to a single base64-encoded command."""
         script = to_text(script)
 
         if script == u'-':