Multi-line string block formatting (Python recipe) by Brett Levin

ActiveState Code (http://code.activestate.com/recipes/145672/)

Control how much indentation to trim? You might not want all the common indentation to be trimmed from a block. Perhaps a marker for each block could indicate where to trim up to.

Re: Control how much indentation to trim? What I do is prefix the trimmed block with as much indentation has I need wherever I'm emitting the code. The Script object that I submit trimmed fragments to has an internal indentation level that it keeps track of, so each line submitted becomes

'\t'*indentLevel + lineText

The idea of this function is that you free it from the indentation of the surrounding Python code, not that you place it into some new indent level, since that depends on where you emit the code.

Note, though, that relative indentation IS preserved after the first line; you can have

htmlFag = formatBlock('''
....<p>
....::::Paragraph text goes here.
....</p>
''')

Where '.' whitespace gets trimmed but ':' is left intact.

Re: Control how much indentation to trim? What I do is prefix the trimmed block with as much indentation as needed for wherever I'm emitting the code. The way I do that is that the Script object that I submit trimmed fragments to has an internal indentation level that it keeps track of, so each line submitted becomes

'\t'*indentLevel + lineText

The idea of formatBlock() is that you free text from the indentation of the surrounding Python code, not that you place it into some new indent level, since that depends on where you emit the text.

Note, though, that relative indentation IS preserved after the first line; you can have

htmlFag = formatBlock('''
....<p>
....::::Paragraph text goes here.
....</p>
''')

Where '.' whitespace gets trimmed but ':' is left intact. Does that address what you were thinking of?

Re: Control how much indentation to trim? What I do is prefix the trimmed block with as much indentation as needed for wherever I'm emitting the code. The way I do that is that the Script object that I submit trimmed fragments to has an internal indentation level that it keeps track of, so each line submitted becomes

'\t'*indentLevel + lineText

The idea of formatBlock() is that you free text from the indentation of the surrounding Python code, not that you place it into some new indent level, since that depends on where you emit the text.

Note, though, that relative indentation IS preserved after the first line; you can have

htmlFrag = formatBlock('''
....<p>
....::::Paragraph text goes here.
....</p>
''')

Where '.' whitespace gets trimmed but ':' is left intact. Does that address what you were thinking of?

Re: Control how much indentation to trim? I made a small modification of this useful recipe to suite my needs for indentation. I added an 'nlspaces' (number of leading spaces) parameter to the function call so that the user can specify the number of spaces that should be prepended to each line in the final return string.

The recipe then becomes

def format_block(block,nlspaces=0):
    '''Format the given block of text, trimming leading/trailing
    empty lines and any leading whitespace that is common to all lines.
    The purpose is to let us list a code block as a multiline,
    triple-quoted Python string, taking care of
    indentation concerns.'''

    import re

    # separate block into lines
    lines = str(block).split('\n')

    # remove leading/trailing empty lines
    while lines and not lines[0]:  del lines[0]
    while lines and not lines[-1]: del lines[-1]

    # look at first line to see how much indentation to trim
    ws = re.match(r'\s*',lines[0]).group(0)
    if ws:
        lines = map( lambda x: x.replace(ws,'',1), lines )

    # remove leading/trailing blank lines (after leading ws removal)
    # we do this again in case there were pure-whitespace lines
    while lines and not lines[0]:  del lines[0]
    while lines and not lines[-1]: del lines[-1]

    # account for user-specified leading spaces
    flines = ['%s%s' % (' '*nlspaces,line) for line in lines]

    return '\n'.join(flines)+'\n'

Receipe doesn't handle text where first line is not aligned. As part of a code generator, I often need to output fragments like:

txt = """
            x = a[i] + b[i];
        }
    }
    """
method.addlines(codeblock(2, txt)) # put at tabstop 2

The code is split up into one function that removes the whitespace, and one that outputs the result in the right position.

def ltrimBlock(s):
    w = len(s)
    s = s.strip('\n') # leading/trailing empty lines
    lines = s.expandtabs(4).split('\n')

    # find w, the smallest indent of a line with content
    for line in lines:
        line2 = line.lstrip()
        if line2:
            w = min(w, len(line)-len(line2))

    return [line[w:] for line in lines]

def codeblock(ntabs, text):
    """Return list of correctly indented lines."""
    tabs = '\t' * ntabs
    return [tabs+line for line in ltrimBlock(text)]

-- bjorn

Of course in Python 2.7 8 years later there is the Python library wraptext.

But here is an slightly altered version of Bjorn Pettersen's recipe above.

def ltrimBlock(s, i=0, tz=4, sp=' ', n='\n'):
    p = sp * i  # p = line prefix

    # break the lines down
    st = s.strip(n).expandtabs(sz).split(n)   # list of lines

    # get the smallest indent
    w = min([len(l)-len(l.lstrip()) for l in st if l.lstrip()])

    # rebuild block with new indent
    b = n.join([p + l[w:] for l in st])

    return b

I kept the varible names short to mirror Bjorn's example. Personally I'd use longer names and add a doc string. I'd not likely make a generator out of it as for block text like this I'd often use this just for docstrings.