Paragraphs

1.0.1 · maintenance · verified Thu Apr 16

Paragraphs is a Python library designed to simplify the incorporation of long strings into Python code, making them more readable and maintainable. It provides a simple function to format multi-line strings, aiming to prevent common formatting issues that arise with extensive text blocks in code. The current version is 1.0.1, and its release cadence appears to be infrequent, with the last update in 2019.

Common errors

```
ModuleNotFoundError: No module named 'paragraphs'
```
cause The 'paragraphs' library has not been installed or is not accessible in the current Python environment.

fix Install the library using pip: `pip install paragraphs`.
```
AttributeError: module 'paragraphs' has no attribute 'par'
```
cause You are trying to access 'par' as an attribute of the 'paragraphs' module, but it should be imported directly.

fix Change your import statement from `import paragraphs` to `from paragraphs import par`.

Warnings

gotcha The `paragraphs` library provides a single `par` function. Its main purpose is to dedent and wrap multiline strings. If you expect more advanced text processing, like natural language paragraph detection or rich text rendering, this is not the correct library; consider `to-paragraphs` or `pyparagraph` respectively.
Fix: Ensure `paragraphs` matches your text processing needs. For semantic paragraph detection, try `to-paragraphs`. For Knuth-Plass line-breaking with PIL rendering, look at `pyparagraph`.
deprecated The library has not seen updates since 2019 (version 1.0.1). While its simple functionality might remain stable, active development and compatibility with newer Python features or more complex text formatting needs are not guaranteed.
Fix: For mission-critical projects or those requiring active maintenance, evaluate alternatives or consider vendoring the code if its current functionality suffices and no breaking changes are anticipated from Python updates.

Install

pip install paragraphs Install stable version

Imports

par
wrong:
```
import paragraphs; paragraphs.par(...)
```
correct:
```
from paragraphs import par
```
The primary utility is the 'par' function, usually imported directly for conciseness.

Quickstart

The `par` function takes a multi-line string (often a triple-quoted string) and formats it, typically by dedenting and re-wrapping it to remove extraneous whitespace and improve readability. This is particularly useful for constructing human-readable messages or documentation within the code.

from paragraphs import par

long_text = par(
    """
    This is a very long string that needs to be incorporated
    into Python code without looking messy. The 'paragraphs'
    library helps format such text blocks beautifully, handling
    line breaks and indentation consistently. It's especially
    useful for error messages, documentation strings, or large
    text data that needs to be easily editable and readable
    within the code itself.
    """
)

print(long_text)
# Expected output will be the text, re-wrapped and dedented automatically by 'par'.
# The exact wrapping depends on the internal logic of 'par'.

# Example of usage within an exception message:
class CustomError(Exception):
    def __init__(self, detail: str):
        self.detail = detail

    def __str__(self):
        return par(
            f"""
            An error occurred: {self.detail}. This message is designed
            to be human-readable and automatically formatted by 'par'.
            The original issue was due to an unexpected input value.
            Please review the input and try again.
            """
        )

try:
    raise CustomError("Invalid configuration file")
except CustomError as e:
    print(e)

view raw JSON →