Repr Formatting API

Scikit-learn style repr and HTML formatting.

ReprMixin

pyreprint.formatting.repr.ReprMixin

Mixin providing scikit-learn style repr and repr_html.

This mixin automatically generates a formatted repr based on the class's init parameters. It also provides repr_html for rich display in Jupyter notebooks.

To use, simply inherit from this mixin:

Example

class MyEstimator(ReprMixin): ... def init(self, alpha=1.0, max_iter=100): ... self.alpha = alpha ... self.max_iter = max_iter est = MyEstimator(alpha=0.5) print(est) MyEstimator(alpha=0.5, max_iter=100)

Attributes:

Name	Type	Description
_repr_max_line_length	int	Maximum line length for repr.
_repr_compact	bool	Whether to use compact format when possible.
_repr_html_style	str	CSS style for HTML repr.

Functions

__repr__()

Return a formatted string representation.

Source code in pyreprint/formatting/repr.py

def __repr__(self) -> str:
    """Return a formatted string representation."""
    return format_repr(
        self,
        max_line_length=self._repr_max_line_length,
        compact=self._repr_compact,
    )

get_params(deep=True)

Get parameters for this instance (sklearn-compatible).

Parameters:

Name	Type	Description	Default
deep	bool	Whether to return nested object params.	True

Returns:

Type	Description
Dict[str, Any]	Dictionary of parameter names to values.

Source code in pyreprint/formatting/repr.py

def get_params(self, deep: bool = True) -> Dict[str, Any]:
    """Get parameters for this instance (sklearn-compatible).

    Args:
        deep: Whether to return nested object params.

    Returns:
        Dictionary of parameter names to values.
    """
    params = {}
    for name in self._get_param_names():
        value = getattr(self, name, None)
        params[name] = value

        if deep and hasattr(value, "get_params"):
            nested = value.get_params(deep=True)
            for key, val in nested.items():
                params[f"{name}__{key}"] = val

    return params

set_params(**params)

Set parameters for this instance (sklearn-compatible).

Parameters:

Name	Type	Description	Default
**params	Any	Parameters to set.	{}

Returns:

Type	Description
'ReprMixin'	self

Source code in pyreprint/formatting/repr.py

def set_params(self, **params: Any) -> "ReprMixin":
    """Set parameters for this instance (sklearn-compatible).

    Args:
        **params: Parameters to set.

    Returns:
        self
    """
    for key, value in params.items():
        if "__" in key:
            # Nested parameter
            parts = key.split("__", 1)
            nested_obj = getattr(self, parts[0])
            nested_obj.set_params(**{parts[1]: value})
        else:
            setattr(self, key, value)
    return self

format_repr

pyreprint.formatting.repr.format_repr(obj, params=None, max_line_length=80, compact=True)

Format an object's repr in scikit-learn style.

Parameters:

Name	Type	Description	Default
obj	Any	The object to format.	required
params	Optional[Dict[str, Any]]	Dictionary of parameter names to values. If None, attempts to extract from object.	None
max_line_length	int	Maximum line length before wrapping.	80
compact	bool	Whether to use compact single-line format when possible.	True

Returns:

Type	Description
str	Formatted repr string.

Example

class MyClass: ... def init(self, a=1, b="hello"): ... self.a = a ... self.b = b obj = MyClass(a=42, b="world") print(format_repr(obj)) MyClass(a=42, b='world')

Source code in pyreprint/formatting/repr.py

def format_repr(
    obj: Any,
    params: Optional[Dict[str, Any]] = None,
    max_line_length: int = 80,
    compact: bool = True,
) -> str:
    """Format an object's repr in scikit-learn style.

    Args:
        obj: The object to format.
        params: Dictionary of parameter names to values.
                If None, attempts to extract from object.
        max_line_length: Maximum line length before wrapping.
        compact: Whether to use compact single-line format when possible.

    Returns:
        Formatted repr string.

    Example:
        >>> class MyClass:
        ...     def __init__(self, a=1, b="hello"):
        ...         self.a = a
        ...         self.b = b
        >>> obj = MyClass(a=42, b="world")
        >>> print(format_repr(obj))
        MyClass(a=42, b='world')
    """
    class_name = obj.__class__.__name__

    # Get parameters
    if params is None:
        param_names = _get_param_names(obj.__class__)
        params = {}
        for name in param_names:
            if hasattr(obj, name):
                params[name] = getattr(obj, name)
            elif hasattr(obj, f"_{name}"):
                params[name] = getattr(obj, f"_{name}")

    if not params:
        return f"{class_name}()"

    # Format parameter strings
    param_strs = [f"{k}={_format_value(v)}" for k, v in params.items()]

    # Try compact format first
    compact_repr = f"{class_name}({', '.join(param_strs)})"
    if compact and len(compact_repr) <= max_line_length:
        return compact_repr

    # Multi-line format
    indent = " " * (len(class_name) + 1)
    lines = [f"{class_name}({param_strs[0]},"]
    for param_str in param_strs[1:-1]:
        lines.append(f"{indent}{param_str},")
    if len(param_strs) > 1:
        lines.append(f"{indent}{param_strs[-1]})")
    else:
        lines[-1] = lines[-1].rstrip(",") + ")"

    return "\n".join(lines)

ReprConfig

pyreprint.formatting.repr.ReprConfig(max_line_length=80, compact=True, show_types=False, max_value_length=40)

Configuration for repr formatting.

This class allows customizing the default repr behavior.

Attributes:

Name	Type	Description
max_line_length		Maximum line length before wrapping.
compact		Whether to use compact format when possible.
show_types		Whether to show type annotations.
max_value_length		Maximum length for value representations.

Source code in pyreprint/formatting/repr.py

def __init__(
    self,
    max_line_length: int = 80,
    compact: bool = True,
    show_types: bool = False,
    max_value_length: int = 40,
) -> None:
    self.max_line_length = max_line_length
    self.compact = compact
    self.show_types = show_types
    self.max_value_length = max_value_length

HTML Formatting

html_repr

pyreprint.formatting.html.html_repr(obj, style='sklearn', params=None, collapsible=False)

Generate HTML representation of an object.

Parameters:

Name	Type	Description	Default
obj	Any	The object to format.	required
style	str	Style theme ('sklearn', 'dark', 'minimal').	'sklearn'
params	Optional[Dict[str, Any]]	Dictionary of parameter names to values. If None, attempts to extract from object.	None
collapsible	bool	Whether to make the repr collapsible.	False

Returns:

Type	Description
str	HTML string representation.

Example

class MyClass: ... def init(self, a=1): ... self.a = a obj = MyClass() html = html_repr(obj)

Source code in pyreprint/formatting/html.py

def html_repr(
    obj: Any,
    style: str = "sklearn",
    params: Optional[Dict[str, Any]] = None,
    collapsible: bool = False,
) -> str:
    """Generate HTML representation of an object.

    Args:
        obj: The object to format.
        style: Style theme ('sklearn', 'dark', 'minimal').
        params: Dictionary of parameter names to values.
                If None, attempts to extract from object.
        collapsible: Whether to make the repr collapsible.

    Returns:
        HTML string representation.

    Example:
        >>> class MyClass:
        ...     def __init__(self, a=1):
        ...         self.a = a
        >>> obj = MyClass()
        >>> html = html_repr(obj)
    """
    class_name = obj.__class__.__name__

    # Get parameters
    if params is None:
        from pyreprint.formatting.repr import _get_param_names

        param_names = _get_param_names(obj.__class__)
        params = {}
        for name in param_names:
            if hasattr(obj, name):
                params[name] = getattr(obj, name)
            elif hasattr(obj, f"_{name}"):
                params[name] = getattr(obj, f"_{name}")

    # Get CSS
    css = STYLES.get(style, STYLES["sklearn"])

    # Build HTML
    parts = []
    parts.append(css)

    if collapsible:
        parts.append('<details class="pyreprint-repr">')
        summary = f'<span class="class-name">{html.escape(class_name)}</span>(...)'
        parts.append(f"<summary>{summary}</summary>")
        parts.append('<div style="padding-left: 20px; margin-top: 8px;">')

        for name, value in params.items():
            value_class = _get_value_class(value)
            value_str = _format_html_value(value)
            parts.append(
                f'<div><span class="param-name">{html.escape(name)}</span>'
                f'<span class="punctuation">=</span>'
                f'<span class="param-value {value_class}">{value_str}</span></div>'
            )

        parts.append("</div>")
        parts.append("</details>")
    else:
        parts.append('<span class="pyreprint-repr">')
        parts.append(f'<span class="class-name">{html.escape(class_name)}</span>')
        parts.append('<span class="punctuation">(</span>')

        param_parts = []
        for name, value in params.items():
            value_class = _get_value_class(value)
            value_str = _format_html_value(value)
            param_parts.append(
                f'<span class="param-name">{html.escape(name)}</span>'
                f'<span class="punctuation">=</span>'
                f'<span class="param-value {value_class}">{value_str}</span>'
            )

        parts.append('<span class="punctuation">, </span>'.join(param_parts))
        parts.append('<span class="punctuation">)</span>')
        parts.append("</span>")

    return "".join(parts)

HTMLFormatter

pyreprint.formatting.html.HTMLFormatter(style='sklearn', collapsible=False, max_value_length=40)

Configurable HTML formatter for objects.

This class provides a reusable formatter with customizable settings.

Parameters:

Name	Type	Description	Default
style	str	Style theme ('sklearn', 'dark', 'minimal').	'sklearn'
collapsible	bool	Whether to make repr collapsible by default.	False
max_value_length	int	Maximum length for value representations.	40

Example

formatter = HTMLFormatter(style='dark', collapsible=True) html = formatter.format(my_object)

Source code in pyreprint/formatting/html.py

def __init__(
    self,
    style: str = "sklearn",
    collapsible: bool = False,
    max_value_length: int = 40,
) -> None:
    self.style = style
    self.collapsible = collapsible
    self.max_value_length = max_value_length

Functions

__call__(obj, **kwargs)

Format an object (shortcut for format method).

Source code in pyreprint/formatting/html.py

def __call__(self, obj: Any, **kwargs: Any) -> str:
    """Format an object (shortcut for format method)."""
    return self.format(obj, **kwargs)

format(obj, params=None, collapsible=None)

Format an object as HTML.

Parameters:

Name	Type	Description	Default
obj	Any	The object to format.	required
params	Optional[Dict[str, Any]]	Optional parameter dictionary override.	None
collapsible	Optional[bool]	Override default collapsible setting.	None

Returns:

Type	Description
str	HTML string representation.

Source code in pyreprint/formatting/html.py

def format(
    self,
    obj: Any,
    params: Optional[Dict[str, Any]] = None,
    collapsible: Optional[bool] = None,
) -> str:
    """Format an object as HTML.

    Args:
        obj: The object to format.
        params: Optional parameter dictionary override.
        collapsible: Override default collapsible setting.

    Returns:
        HTML string representation.
    """
    use_collapsible = collapsible if collapsible is not None else self.collapsible
    return html_repr(
        obj,
        style=self.style,
        params=params,
        collapsible=use_collapsible,
    )

display_html

pyreprint.formatting.html.display_html(obj, **kwargs)

Display an object's HTML repr in Jupyter.

Parameters:

Name	Type	Description	Default
obj	Any	The object to display.	required
**kwargs	Any	Arguments passed to html_repr.	{}

Source code in pyreprint/formatting/html.py

def display_html(obj: Any, **kwargs: Any) -> None:
    """Display an object's HTML repr in Jupyter.

    Args:
        obj: The object to display.
        **kwargs: Arguments passed to html_repr.
    """
    try:
        from IPython.display import HTML, display

        html_str = html_repr(obj, **kwargs)
        display(HTML(html_str))
    except ImportError:
        # Not in Jupyter, fall back to print
        print(repr(obj))