Pretty Printing

def pformat(value, indent=0, indent_first=False, highlight=False) -> str:
    """
    Format value as pretty string with intelligent structure formatting.
    
    Parameters:
    - value: Object to format
    - indent: Initial indentation level (default: 0)
    - indent_first: Indent the first line (default: False)
    - highlight: Apply syntax highlighting with Pygments (default: False)
    
    Returns:
    Formatted string representation with proper indentation and structure
    """

from devtools import pformat

# Format complex nested data
data = {
    'users': [
        {'name': 'Alice', 'age': 30, 'active': True},
        {'name': 'Bob', 'age': 25, 'active': False}
    ],
    'config': {
        'debug': True,
        'timeout': 30.0,
        'retries': 3
    }
}

formatted = pformat(data, highlight=True)
print(formatted)
# Output: Nicely indented structure with syntax highlighting

# Format with custom indentation
formatted_indented = pformat(data, indent=4, indent_first=True)
print(formatted_indented)

def pprint(s, file=None) -> None:
    """
    Pretty print with automatic highlighting detection based on TTY status.
    
    Parameters:
    - s: Object to pretty print
    - file: Output file (default: stdout)
    """

from devtools import pprint
import numpy as np

# Pretty print to stdout with auto-highlighting
complex_data = {
    'matrix': np.array([[1, 2, 3], [4, 5, 6]]),
    'text': 'A very long string that will be wrapped appropriately for better readability',
    'nested': {'a': [1, 2, 3], 'b': {4, 5, 6}}
}
pprint(complex_data)

# Pretty print to file
with open('output.txt', 'w') as f:
    pprint(complex_data, file=f)

class PrettyFormat:
    """
    Configurable pretty formatter for complex data structures.
    """
    def __init__(
        self,
        indent_step: int = 4,
        indent_char: str = ' ',
        repr_strings: bool = False,
        simple_cutoff: int = 10,
        width: int = 120,
        yield_from_generators: bool = True
    ):
        """
        Initialize PrettyFormat with custom formatting options.
        
        Parameters:
        - indent_step: Number of spaces per indentation level (default: 4)
        - indent_char: Character used for indentation (default: ' ')
        - repr_strings: Use repr() for strings instead of pretty formatting (default: False)
        - simple_cutoff: Maximum length for simple one-line representation (default: 10)
        - width: Maximum line width for formatting (default: 120)
        - yield_from_generators: Iterate through generators for display (default: True)
        """
    
    def __call__(self, value, indent=0, indent_first=False, highlight=False) -> str:
        """
        Format value as pretty string.
        
        Parameters:
        - value: Object to format
        - indent: Initial indentation level
        - indent_first: Indent the first line
        - highlight: Apply syntax highlighting
        
        Returns:
        Formatted string representation
        """

from devtools import PrettyFormat

# Create custom formatter with different settings
compact_formatter = PrettyFormat(
    indent_step=2,
    width=80,
    simple_cutoff=20
)

# Create formatter that always uses repr for strings
repr_formatter = PrettyFormat(repr_strings=True)

# Use custom formatter
data = {'key': 'value', 'numbers': [1, 2, 3, 4, 5]}
compact_output = compact_formatter(data)
repr_output = repr_formatter(data)

from dataclasses import dataclass
from devtools import pprint

@dataclass
class Person:
    name: str
    age: int
    active: bool = True

person = Person("Alice", 30)
pprint(person)
# Output: Person(
#     name='Alice',
#     age=30,
#     active=True,
# )

from collections import namedtuple
from devtools import pprint

Point = namedtuple('Point', ['x', 'y', 'z'])
point = Point(1.0, 2.0, 3.0)
pprint(point)
# Output: Point(
#     x=1.0,
#     y=2.0,
#     z=3.0,
# )

from devtools import pprint

def number_generator():
    for i in range(5):
        yield i * 2

# Generator contents are displayed when yield_from_generators=True
pprint(number_generator())
# Output: (
#     0,
#     2,
#     4,
#     6,
#     8,
# )

from devtools import pprint

long_text = "This is a very long string that will be wrapped across multiple lines to improve readability and fit within the specified width constraints."

pprint(long_text)
# Output: (
#     'This is a very long string that will be wrapped across '
#     'multiple lines to improve readability and fit within the '
#     'specified width constraints.'
# )

class CustomObject:
    def __init__(self, data):
        self.data = data
    
    def __pretty__(self, fmt, skip_exc):
        yield 'CustomObject('
        yield 1  # Increase indentation
        yield fmt({'data': self.data})
        yield -1  # Decrease indentation
        yield ')'

from devtools import pprint
obj = CustomObject([1, 2, 3])
pprint(obj)
# Output: CustomObject(
#     {'data': [1, 2, 3]}
# )

def fmt(v) -> dict:
    """
    Helper function for custom pretty formatting.
    
    Parameters:
    - v: Value to format
    
    Returns:
    Dictionary with special pretty formatting key
    """

class SkipPretty(Exception):
    """
    Exception raised to skip pretty formatting and fall back to repr().
    """

class ConditionalPretty:
    def __init__(self, data, should_pretty=True):
        self.data = data
        self.should_pretty = should_pretty
    
    def __pretty__(self, fmt, skip_exc):
        if not self.should_pretty:
            raise skip_exc  # Falls back to repr()
        yield f'ConditionalPretty({self.data})'

# Assuming SQLAlchemy model
from devtools import pprint

# SQLAlchemy model instance
user = User(name="Alice", email="alice@example.com")
pprint(user)
# Output: User(
#     id=1,
#     name='Alice',
#     email='alice@example.com',
#     posts=<deferred>,  # Deferred attributes shown as <deferred>
# )

# Default pretty formatter instance
pformat: PrettyFormat

# Internal constants
MISSING: object  # Sentinel object for missing values
PRETTY_KEY: str  # Key for pretty formatting dict