Add ability to preserve some whitespace in textwrap.dedent

[Ashark]

Feature or enhancement

Proposal:

From textwrap.dedent() documentation (https://docs.python.org/3/library/textwrap.html):

Remove any common leading whitespace from every line in text.
Note that tabs and spaces are both treated as whitespace,

Sometimes, I want to use textwrap.dedent(), but at the same time, I want it to not cut-off some "wanted" whitespace.

For example, in some places of my project, I want to form a multiline string, where each string is starting with a "\t". Like this:

Attempting to use like this:

                logger_module.warning(textwrap.dedent(f"""\
                    \tr[b[*] Unable to move {old_source_dir}
                    \tr[b[*] to {fullpath}
                    \tr[b[*] Error: {e}
                    \ty[b[*] Will proceed, generating a new source dir."""))

Unfortunately (and expectedly), it removes all leading whitespaces with the starting tabulation symbols.

In my specific project (kde-builder), as a workaround, I could use "]" in the beginning of lines (in the project, the "]" in string is treated as escape sequence for unsetting colored output).
This way, as textwrap.dedent considers "]" as non-whitespace, it preserves the following "\t".

My workaround:

                logger_module.warning(textwrap.dedent(f"""\
                    ]\tr[b[*] Unable to move {old_source_dir}
                    ]\tr[b[*] to {fullpath}
                    ]\tr[b[*] Error: {e}
                    ]\ty[b[*] Will proceed, generating a new source dir."""))

But I would like to be able to not use crutches, and instead use universal solution. For example, a dedent() method could have a parameter to preserve specific substring in the beginning:
like this: preserve_substring="\t", and so

                logger_module.warning(textwrap.dedent(f"""\
                    \tr[b[*] Unable to move {old_source_dir}
                    \tr[b[*] to {fullpath}
                    \tr[b[*] Error: {e}
                    \ty[b[*] Will proceed, generating a new source dir.""", preserve_substring="\t"))

could work as I expect.

Can this be added please?

Has this already been discussed elsewhere?

This is a minor feature, which does not need previous discussion elsewhere

Links to previous discussion of this feature:

No response

[StanFromIreland]

Maybe @AA-Turner is interested in this?

[AA-Turner]

This has the potential to get overly complex, with permitting some characters, or some substrings, or some prefixes. The function is fairly simple, so if you want to implement a modified copy in your own project, feel free to do so.

Thank you for submitting the request, though.

A

[terryjreedy]

I agree. Too many possible idiosyncratic variations and easy to work around. In the present case, replacing a marker char with '\t' is easy.

import textwrap
print(textwrap.dedent(f"""\
          ]r[b[*] Unable to move old_source_dir
          ]y[b[*] Will proceed, generating a new source dir."""
          ).replace(']', '\t'))

produces the desired tabbed lines.

	r[b[*	 Unable to move old_source_dir
	y[b[*	 Will proceed, generating a new source dir.

Non-printable '\a' (alarm, bell), for instance, also works as a marker.

[Ashark]

I have found a better workaround without the need of uglyfying the multi-line string with some prefix. Beautifullness was the reason when using the textwrap.dedent after all. Just wanted to share it, so it may be used by others.

In essence, I just needed to change the two lines containing the regexp with which it catches leading whitespace.

Here are original lines:

_whitespace_only_re = re.compile('^[ \t]+$', re.MULTILINE)
_leading_whitespace_re = re.compile('(^[ \t]*)(?:[^ \t\n])', re.MULTILINE)

Wanted to change them to these:

textwrap._whitespace_only_re = re.compile('^ +$', re.MULTILINE)
textwrap._leading_whitespace_re = re.compile('(^ *)[^ \n]', re.MULTILINE)

I highly doubt anybody uses tabs in their python sources today. But still, as authors of textwrap did not want to change that, and copying the dedent function entirely to your project is not wanted, the following can be done:

Create a file named textwrap_mod.py in your project, and use the following content there:

import textwrap
import re

textwrap._whitespace_only_re = re.compile('^ +$', re.MULTILINE)
textwrap._leading_whitespace_re = re.compile('(^ *)[^ \n]', re.MULTILINE)

Now, in your project, you just need to change the import statements:

change this:

import textwrap

into this:

from textwrap_mod import textwrap

Now, you can use textwrap.dedent() as usual, and it will preserve the leading "\t" (tabulation) symbols.

Full example:

from textwrap_mod import textwrap

def demo_func():
    print(textwrap.dedent("""\
    \tHello
    \t
    \tWorld!
    """))

demo_func()

will print:

	Hello
	
	World!