textwrap3

Warnings

• gotcha Due to its design principle, `textwrap3` adheres to Python 3's sensibilities, especially concerning Unicode. It uses `re.UNICODE` and treats Unicode em-dashes like ASCII '--'. This can lead to subtle differences in wrapping behavior compared to the native `textwrap` module in older Python 2.x environments where Unicode handling might differ.
  Fix: Be aware of potential Unicode handling discrepancies. Test text wrapping behavior thoroughly with diverse character sets, especially when migrating from native Python 2.x `textwrap`.
• gotcha The `wrap()` and `fill()` functions, by default, replace all internal whitespace characters (including newlines and tabs) with single spaces before wrapping. Existing newlines in multi-paragraph input will be collapsed. If you need to preserve original newlines as paragraph breaks, process paragraphs separately or use `replace_whitespace=False` (though this might lead to other formatting challenges).
  Fix: Pass `replace_whitespace=False` to `wrap()` or `TextWrapper` constructor if you want to prevent the collapsing of whitespace. For multi-paragraph text, it's often better to split the text into paragraphs, wrap each, and then join them back.
• gotcha For modern Python 3.6+ environments, `textwrap3` is generally unnecessary. All the features it backports are already present in the standard library's `textwrap` module. Installing it in these environments adds an unnecessary dependency.
  Fix: For Python 3.6 and later, use the built-in `textwrap` module directly (e.g., `import textwrap`) instead of `textwrap3`. The functionality is identical.
• gotcha The underlying `textwrap.wrap()` logic (inherited by `textwrap3`) can exhibit poor performance (quadratic time complexity) when wrapping text containing extremely long, unbroken words (e.g., a very long string without spaces or hyphens) if `break_long_words` is `True` (the default).
  Fix: If you encounter performance issues with very long words, consider setting `break_on_hyphens=False` or `break_long_words=False` in the `TextWrapper` constructor or `wrap`/`fill` function calls if breaking long words is not critical, or pre-processing the text to insert break points.

Install

• pip install textwrap3 Install latest version

Imports

• wrap

  from textwrap3 import wrap

  Import functions directly from 'textwrap3' as you would from the standard 'textwrap' module.
• fill

  from textwrap3 import fill

  Import functions directly from 'textwrap3' as you would from the standard 'textwrap' module.
• shorten

  from textwrap3 import shorten

  This function, backported from Python 3.4+, is available directly from 'textwrap3'.
• TextWrapper

  from textwrap3 import TextWrapper

  The TextWrapper class for advanced configuration is imported directly.

Quickstart

Demonstrates basic text wrapping, filling, and shortening using the core functions from the textwrap3 library.

from textwrap3 import wrap, fill, shorten

long_text = """This is a very long string that needs to be wrapped 
into several lines to be more readable. It demonstrates the basic functionality of the textwrap3 library, which is a backport of Python 3.6's textwrap module."""

# Using wrap to get a list of lines
wrapped_lines = wrap(long_text, width=40)
print("Wrapped lines (list):")
for line in wrapped_lines:
    print(line)

print("\n" + "-" * 30 + "\n")

# Using fill to get a single string with newlines
filled_text = fill(long_text, width=40)
print("Filled text (single string):")
print(filled_text)

print("\n" + "-" * 30 + "\n")

# Using shorten to truncate text
shortened_text = shorten(long_text, width=50, placeholder=' [...]')
print("Shortened text:")
print(shortened_text)