tessl/pypi-pipdeptree

Command line utility to show dependency tree of packages.

—

Pending

Overview

Eval results

Files

Output Rendering

Name: tessl/pypi-pipdeptree
Author: tessl

Renders dependency trees in multiple formats including text, JSON, GraphViz, Mermaid, and freeze formats with extensive customization options.

Capabilities

Main Render Function

Primary entry point for rendering dependency trees in various formats.

def render(options: Options, tree: PackageDAG) -> None:
    """
    Render dependency tree in the format specified by options.
    
    Automatically selects the appropriate renderer based on options:
    - JSON output if options.json is True
    - Nested JSON tree if options.json_tree is True  
    - Mermaid diagram if options.mermaid is True
    - GraphViz output if options.output_format is specified
    - Freeze format if options.freeze is True
    - Text format (default) for all other cases
    
    Parameters:
    - options: CLI options specifying output format and settings
    - tree: PackageDAG to render
    """

Text Rendering

Human-readable hierarchical text output with optional licensing information.

def render_text(
    tree: PackageDAG,
    max_depth: float,
    encoding: str,
    list_all: bool,
    include_license: bool,
) -> None:
    """
    Render dependency tree as indented text to stdout.
    
    Parameters:
    - tree: PackageDAG to render
    - max_depth: Maximum depth to display (float('inf') for unlimited)
    - encoding: Character encoding for output
    - list_all: Whether to list all dependencies at top level
    - include_license: Whether to include license information
    """

JSON Rendering

Machine-readable JSON output formats for programmatic consumption.

def render_json(tree: PackageDAG) -> str:
    """
    Render dependency tree as flat JSON array.
    
    Each package is represented as an object with dependencies listed
    as separate objects in the same array structure.
    
    Parameters:
    - tree: PackageDAG to render
    
    Returns:
    JSON string representation
    """

def render_json_tree(tree: PackageDAG) -> str:
    """
    Render dependency tree as nested JSON structure.
    
    Creates a hierarchical JSON structure that mirrors the text output
    format with nested dependency relationships.
    
    Parameters:
    - tree: PackageDAG to render
    
    Returns:
    Nested JSON string representation
    """

Freeze Format Rendering

pip freeze-compatible output format for requirements files.

def render_freeze(
    tree: PackageDAG,
    max_depth: float,
    list_all: bool,
) -> None:
    """
    Render dependency tree in pip freeze format to stdout.
    
    Produces output compatible with pip freeze, including:
    - Editable packages with -e flag
    - VCS URLs for packages installed from git/etc
    - Standard package==version format
    
    Parameters:
    - tree: PackageDAG to render
    - max_depth: Maximum depth to include
    - list_all: Whether to list all dependencies at top level
    """

def dist_to_frozen_repr(dist: Distribution) -> str:
    """
    Convert a Distribution object to pip freeze-compatible representation.
    
    Creates freeze format strings including editable packages with -e flag,
    VCS URLs for packages installed from git/etc, and standard package==version format.
    
    Parameters:
    - dist: importlib.metadata.Distribution object to convert
    
    Returns:
    String in pip freeze format
    """

GraphViz Rendering

Visual graph output using GraphViz for creating diagrams and images.

def render_graphviz(
    tree: PackageDAG,
    output_format: str,
    reverse: bool,
) -> None:
    """
    Render dependency tree using GraphViz for visual output.
    
    Generates GraphViz DOT format and optionally renders to image formats.
    Supports all GraphViz output formats: png, svg, pdf, dot, etc.
    
    Parameters:
    - tree: PackageDAG to render
    - output_format: GraphViz output format (png, svg, pdf, dot, etc.)
    - reverse: Whether tree is in reverse mode (affects node coloring)
    """

Mermaid Rendering

Mermaid flow diagram format for web-based visualization.

def render_mermaid(tree: PackageDAG) -> str:
    """
    Render dependency tree as Mermaid flow diagram.
    
    Creates a Mermaid-compatible flow diagram showing package dependencies
    that can be rendered in GitHub, web browsers, or Mermaid tools.
    
    Parameters:
    - tree: PackageDAG to render
    
    Returns:
    Mermaid diagram string
    """

Usage Examples

Basic Text Rendering

from pipdeptree._render import render_text
from pipdeptree._models import PackageDAG
from pipdeptree._discovery import get_installed_distributions

# Create dependency tree
distributions = get_installed_distributions()
tree = PackageDAG.from_pkgs(distributions)

# Render as text with licenses
render_text(
    tree=tree,
    max_depth=float('inf'),
    encoding='utf-8', 
    list_all=False,
    include_license=True
)

JSON Output Formats

from pipdeptree._render import render_json, render_json_tree
import json

# Flat JSON format
json_output = render_json(tree)
data = json.loads(json_output)
print(f"Found {len(data)} packages")

# Nested JSON tree format  
tree_output = render_json_tree(tree)
tree_data = json.loads(tree_output)
print("Dependency tree structure:")
for pkg in tree_data:
    print(f"- {pkg['package_name']} ({pkg['installed_version']})")

Using the Main Render Function

from pipdeptree._cli import get_options
from pipdeptree._render import render

# Parse options and render accordingly
options = get_options(['--json-tree', '--depth', '2'])
render(options, tree)

# Different output formats
options_json = get_options(['--json'])
render(options_json, tree)

options_mermaid = get_options(['--mermaid']) 
render(options_mermaid, tree)

Freeze Format Output

from pipdeptree._render import render_freeze

# Generate pip freeze compatible output
render_freeze(
    tree=tree,
    max_depth=float('inf'),
    list_all=True  # Include all packages at top level
)

# Output can be redirected to create requirements file:
# python -c "render_freeze(...)" > requirements.txt

GraphViz Visual Output

from pipdeptree._render import render_graphviz

# Generate PNG image
render_graphviz(
    tree=tree,
    output_format='png',
    reverse=False
)

# Generate SVG for web display
render_graphviz(
    tree=tree, 
    output_format='svg',
    reverse=False
)

# Generate DOT source for further processing
render_graphviz(
    tree=tree,
    output_format='dot', 
    reverse=False
)

Output Format Details

Text Format

The default text format shows hierarchical dependency relationships:

Flask==2.3.2
  - blinker [required: >=1.6.2, installed: 1.6.2]
  - click [required: >=8.1.3, installed: 8.1.3]
    - colorama [required: Any, installed: 0.4.6]
  - itsdangerous [required: >=2.1.2, installed: 2.1.2]
  - Jinja2 [required: >=3.1.2, installed: 3.1.2]
    - MarkupSafe [required: >=2.0, installed: 2.2.1]
  - Werkzeug [required: >=2.3.6, installed: 2.3.6]

With licenses enabled:

Flask==2.3.2 (BSD License)
  - blinker [required: >=1.6.2, installed: 1.6.2] (MIT License)

JSON Format

Flat JSON array with each package as a separate object:

[
  {
    "key": "flask",
    "package_name": "Flask", 
    "installed_version": "2.3.2",
    "dependencies": [
      {
        "key": "blinker",
        "package_name": "blinker",
        "installed_version": "1.6.2",
        "required_version": ">=1.6.2"
      }
    ]
  }
]

JSON Tree Format

Nested structure mirroring the text hierarchy:

[
  {
    "package_name": "Flask",
    "installed_version": "2.3.2", 
    "dependencies": [
      {
        "package_name": "blinker",
        "installed_version": "1.6.2",
        "required_version": ">=1.6.2",
        "dependencies": []
      }
    ]
  }
]

Freeze Format

pip freeze compatible output:

Flask==2.3.2
blinker==1.6.2
click==8.1.3
colorama==0.4.6
-e git+https://github.com/user/repo.git@abc123#egg=mypackage

Mermaid Format

Flow diagram syntax:

graph TD
    Flask --> blinker
    Flask --> click
    click --> colorama
    Flask --> itsdangerous
    Flask --> Jinja2
    Jinja2 --> MarkupSafe
    Flask --> Werkzeug

GraphViz DOT Format

DOT language for graph visualization:

digraph {
    "Flask" [label="Flask\n2.3.2"];
    "blinker" [label="blinker\n1.6.2"];
    "Flask" -> "blinker";
}

Rendering Configuration

Each render function accepts specific configuration parameters:

Text Rendering Options

max_depth: Limit tree depth display
encoding: Character encoding for output
list_all: Show all packages at top level vs. tree structure
include_license: Add license information to output

Freeze Rendering Options

max_depth: Limit which packages to include
list_all: Include all dependencies vs. just top-level

GraphViz Options

output_format: Image format (png, svg, pdf) or dot source
reverse: Affects node coloring for reverse dependency trees

The rendering system integrates with pipdeptree's warning system and respects the configured warning levels for error handling during output generation.

Install with Tessl CLI