interpareto is a Python utility for easy creating interactive Pareto charts from pandas.DataFrame objects. It generates standalone HTML files with dynamic visualizations using Plotly.js—viewable in any browser without Jupyter notebooks, servers, or frameworks.
The result is an interactive chart, where the data column used in the plot can be switched.
Example that uses well known movie dataset.
đź“Ś Note
InterPareto doesn’t use Plotly for Python or any server to run. Instead, it generates standalone HTML files with embedded interactive charts using Plotly.js (JavaScript). No server, Jupyter, or browser rendering engine is required at runtime.
This design allows charts to be:
- Viewed offline in any modern web browser,
- Embedded into web apps if needed.
pip install interpareto
import pandas as pd
import interpareto as ipar
sample_df = ipar.generate_pareto_data(100)
ipar.render(sample_df, title="Sample Data Analysis")Of course, not all datasets are suitable for this kind of analysis — but many are.
- Positive numeric values (sales, defects, costs)
- Skewed distributions (few large, many small values)
- Categorical data with measurable impact
- Data w- here the 80/20 principle may apply
- Normally distributed data
- Data with many zero/negative values
- Data without clear categories
- Converts
pandas.DataFrameto interactive standalone HTML Pareto charts - Dynamic column selection: Switch between different data columns in real-time
- Smart data processing: Automatically detects and removes index-like columns
- Data cleaning: Handles NaN values, negatives, and zeros with detailed reporting
- Self-contained HTML files with embedded data—no external dependencies at runtime
- Works independently of web servers—viewable offline in any browser
- Minimal HTML snippet generation: Generate embeddable HTML content for Flask or other web frameworks
import pandas as pd
import interpareto as ipar
# Simple example with 15 data points
df = pd.DataFrame({
"Product": ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O"],
"Sales": [5000, 3200, 2800, 2100, 1900, 1500, 1200, 900, 750, 650, 500, 400, 300, 200, 150],
"Profit": [1200, 800, 333, 222, 40, 111, 100, 90, 12, 60, 60, 55, 45, 12, 2]
})
# Generate chart
ipar.render(df, title="Sales Analysis", to_file="sales_pareto.html")Pareto analysis is based on the Pareto Principle (80/20 rule), which states that roughly 80% of effects come from 20% of causes. InterPareto automatically:
- Sorts data: Orders values from highest to lowest
- Calculates cumulative percentages: Shows running totals as percentage of whole
- Identifies the 80% threshold: Highlights where 80% of total value is reached
- Annotates key insights: Shows what percentage of categories contribute to 80% of value
ipar.render(
df: pd.DataFrame,
to_file: Optional[str] = None,
title: str = "Pareto dashboard",
templ_path: str = TEMPLATE_PATH,
startfile: bool = True,
warnings: bool = True
) -> Union[str, file_object]Parameters:
df: Input pandas DataFrame with numeric columns for analysisto_file: Output HTML file path. If None, returns HTML string instead of writing filetitle: Title for the Pareto dashboardtempl_path: Path to custom HTML template (uses default if not specified)startfile: If True, automatically opens the generated HTML file in default browserwarnings: If True, displays data processing warnings in the output
Returns:
- HTML string if
to_file=None - File object if
to_fileis specified
ipar.render_inline(
df: pd.DataFrame,
**kwargs
) -> strGenerates minimal HTML content suitable for embedding in Flask or other web framework templates. This function:
- Returns only the chart markup and JavaScript
- Excludes full HTML document structure (no
<html>,<head>,<body>tags) - Important: Requires Plotly.js to be loaded in the host page
- Perfect for embedding interactive Pareto analysis in existing web applications
Parameters:
- Same as
render()exceptto_fileis not allowed (always returns string)
ipar.generate_pareto_data(N: int = 15) -> pd.DataFrameGenerates sample data following various statistical distributions for testing and demonstration purposes.
Parameters:
N: Number of data points to generate
Returns:
- DataFrame with sample data including Pareto, normal, uniform, and other distributions
InterPareto automatically processes your data to ensure optimal visualization:
- Index-like column detection: Removes columns that appear to be indices or sequential numbers
- Duplicate index handling: Removes duplicate row indices, keeping the first occurrence
- Numeric column selection: Automatically selects the first 10 numeric columns
- Missing value handling: Removes rows with NaN values
- Negative and zero filtering: Excludes rows with negative values or zeros (configurable)
The library provides detailed feedback about data processing:
# Example processing output
"""
Dropped column 'ID': looks like index
Column 'Revenue': 2 NaNs, (1 negative values, 3 zeros)
Column 'Customers': 0 NaNs, (0 negative values, 1 zeros)
"""Here's a complete Flask application demonstrating how to embed interactive Pareto charts:
from flask import Flask, render_template_string
import interpareto as ipar
app = Flask(__name__)
@app.route("/")
def home():
# Generate sample data (or use your own DataFrame)
df = ipar.generate_pareto_data(50)
df_title = "Pareto Chart Rendered inline in <strong>Flask</strong>"
# Generate the embeddable Pareto chart HTML
string_pareto = ipar.render_inline(df, title=df_title, warnings=False)
return render_template_string(
"""
<!DOCTYPE html>
<html>
<head>
<title>Flask Pareto Dashboard</title>
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<!-- Required: Plotly.js for chart rendering -->
<script src="https://cdnjs.cloudflare.com/ajax/libs/plotly.js/2.26.0/plotly.min.js"></script>
<style>
body {
font-family: "Segoe UI", Roboto, sans-serif;
margin: 0;
padding: 20px;
background-color: #f8f9fa;
}
.container {
max-width: 1200px;
margin: 0 auto;
background: white;
padding: 20px;
border-radius: 8px;
box-shadow: 0 2px 10px rgba(0,0,0,0.1);
}
h1 {
color: #333;
text-align: center;
margin-bottom: 30px;
}
</style>
</head>
<body>
<div class="container">
<h1>My Flask Pareto Dashboard</h1>
{{ inline_pareto | safe }}
</div>
</body>
</html>
""",
inline_pareto=string_pareto,
)
if __name__ == "__main__":
app.run(debug=True)The generated Pareto chart includes:
- Horizontal bar chart: Shows individual values for each category
- Cumulative line: Displays running percentage total
- 80% threshold line: Horizontal dashed line at 80%
- Intersection annotation: Shows where cumulative line crosses 80%
- Dynamic controls: Dropdown to switch between different data columns
đź“Ś Note Currently, modifying chart colors or settings is possible by editing the built-in HTML/JS template or by using a custom template.
Note that the goal of this module is not to replicate functionality of Plotly for Python when it comes to customization.
# Use custom template
ipar.render(
df,
title="Branded Analysis",
templ_path="custom_pareto_template.html",
to_file="branded_pareto.html"
)
# Generate sample data for testing
sample_df = ipar.generate_pareto_data(100)
ipar.render(sample_df, title="Sample Data Analysis")- Python 3.7+
- pandas
- numpy
- Interactive tooltips: Hover for detailed information
- Column switching: Real-time data column selection
- Export options: Built-in Plotly export functionality
- Zoom and pan: Interactive chart exploration
Templates use comnt, a minimal markup system:
<!--[title-->
Dashboard Title
<!--title]-->
const data = /*[p_data*/ [...] /*p_data]*/;MIT License
© Tomasz Sługocki