first commit

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,62 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+*.manifest
+*.spec
+
+# Streamlit
+# .streamlit/
+
+# Virtual environments
+venv/
+ENV/
+env/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Logs
+*.log
+
+# Reports
+report.json

.streamlit/config.toml

@@ -0,0 +1,7 @@
+[server]
+enableCORS = false
+enableXsrfProtection = false
+maxUploadSize = 200
+
+[browser]
+gatherUsageStats = false

Dockerfile

@@ -0,0 +1,20 @@
+FROM python:3.13.5-slim
+
+WORKDIR /app
+
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    curl \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY requirements.txt ./
+COPY src/ ./src/
+
+RUN pip3 install -r requirements.txt
+
+EXPOSE 8501
+
+HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health
+
+ENTRYPOINT ["streamlit", "run", "src/streamlit_app.py", "--server.port=8501", "--server.address=0.0.0.0"]

README.md

@@ -0,0 +1,200 @@
+---
+title: Radon CC Analysis
+emoji: 📊
+colorFrom: blue
+colorTo: green
+sdk: streamlit
+sdk_version: "1.40.0"
+app_file: app.py
+pinned: false
+---
+
+# Radon CC Reader - Cyclomatic Complexity Analyzer
+
+A modern Streamlit web application for analyzing and visualizing Python cyclomatic complexity reports from the [radon](https://radon.readthedocs.io/) library.
+
+## Features
+
+### 📈 Overview Tab
+- Quick metrics: total items, files, average and max complexity
+- Complexity distribution chart
+- Grade distribution chart
+- Scatter plot of complexity by file and grade
+
+### 🔍 Analysis Tab
+- **Filtering**: Filter by type, grade, complexity range, and files
+- **Sorting**: Sort by complexity, grade, name, file, or line number
+- **Search**: Search for specific functions/classes by name
+- **Color Coding**: Visual indicators for grades and complexity levels
+  - Grade A (Green) → F (Dark Red)
+  - Simple (Green) → Very Complex (Dark Red)
+
+### ⚠️ Warnings Tab
+- Identifies items requiring investigation
+- Configurable complexity threshold
+- Configurable risk grades
+- Detailed recommendations for each risky item
+- Expandable item details with severity indicators
+
+### 📋 Details Tab
+- Detailed analysis of individual items
+- Full metrics and location information
+- Automated recommendations based on complexity
+- Quality assessment
+
+## Installation
+
+1. **Clone or navigate to the repository:**
+   ```bash
+   cd c:\repos\radoncc-reader
+   ```
+
+2. **Install dependencies:**
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+## Usage
+
+### Generate a Radon Report
+
+First, generate a cyclomatic complexity report from your Python project using radon:
+
+```bash
+# Generate JSON report for a single file
+radon cc path/to/file.py -j > report.json
+
+# Generate JSON report for entire project
+radon cc path/to/project/ -j > report.json
+```
+
+### Run the App
+
+```bash
+streamlit run app.py
+```
+
+The app will open in your browser at `http://localhost:8501`
+
+### Upload Report
+
+1. Click the file uploader in the left sidebar
+2. Select your JSON report file
+3. The app will parse and display the data
+
+### Or Try Sample Data
+
+Click the "Load Sample Report" button on the home page to see a demo with sample data.
+
+## JSON Report Structure
+
+The app expects a JSON file in the following structure:
+
+```json
+{
+  "file/path.py": [
+    {
+      "type": "class",
+      "rank": "A",
+      "lineno": 7,
+      "complexity": 1,
+      "endline": 8,
+      "name": "ClassName",
+      "col_offset": 0,
+      "methods": [
+        {
+          "type": "method",
+          "rank": "A",
+          "lineno": 10,
+          "classname": "ClassName",
+          "complexity": 3,
+          "endline": 20,
+          "name": "method_name",
+          "col_offset": 4,
+          "closures": []
+        }
+      ]
+    },
+    {
+      "type": "function",
+      "rank": "B",
+      "lineno": 30,
+      "complexity": 5,
+      "endline": 40,
+      "name": "function_name",
+      "col_offset": 0
+    }
+  ]
+}
+```
+
+## Complexity Grades
+
+- **A**: Low complexity (1-3) - Simple and easy to maintain
+- **B**: Low complexity (4-7) - Moderately complex
+- **C**: Moderate complexity - Review recommended
+- **D**: High complexity - Refactoring recommended
+- **F**: Very high complexity (10+) - Critical refactoring needed
+
+## Features & Functionality
+
+### Color Coding System
+- **Grades**: A (Green) → B (Orange) → C-D (Red) → F (Dark Red)
+- **Complexity**: 1-3 (Green) → 4-7 (Orange) → 8-10 (Red) → 10+ (Dark Red)
+
+### Filtering Capabilities
+- Filter by item type (class, function, method, closure)
+- Filter by grade (A, B, C, D, F)
+- Filter by complexity range with slider
+- Filter by specific files
+- Search by name with text input
+
+### Sorting Options
+- Complexity (High→Low or Low→High)
+- Grade (Best→Worst)
+- Name (A→Z)
+- File Path
+- Line Number
+
+### Warnings System
+- Automatic identification of risky code
+- Configurable thresholds
+- Severity-based recommendations
+- Critical items highlighted
+- Up to 20 most critical items shown with detailed analysis
+
+### Detailed Analysis
+- Individual item inspection
+- Full metrics display
+- Location and file information
+- Automated recommendations
+- Quality assessment
+
+## Tips
+
+1. **Code Quality Focus**: Use the Warnings tab to find the most complex code that needs refactoring
+2. **Batch Refactoring**: Sort by complexity to systematically address the most problematic code
+3. **Grade Tracking**: Monitor grade improvements as you refactor
+4. **Search for Patterns**: Use the search function to find all methods matching a pattern
+
+## Technical Stack
+
+- **Streamlit**: Web app framework
+- **Pandas**: Data manipulation and filtering
+- **Plotly**: Interactive visualizations
+- **Python 3.7+**
+
+## Notes
+
+- This app runs entirely locally - your code reports are never sent anywhere
+- The app handles nested methods and closures automatically
+- Large reports (1000+ items) may take a moment to load and filter
+- All filtering and sorting happens in-memory
+
+## License
+
+MIT
+
+---
+
+**Made for Python developers who care about code quality!** 🚀

app.py

@@ -0,0 +1,680 @@
+import json
+from pathlib import Path
+from typing import Any, Dict, List
+
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objects as go
+import streamlit as st
+
+st.set_page_config(
+    page_title="Radon Complexity Analyzer",
+    page_icon="📊",
+    layout="wide",
+    initial_sidebar_state="expanded",
+)
+
+# Custom CSS for better styling
+st.markdown(
+    """
+    <style>
+    .grade-A { color: #2ecc71; font-weight: bold; }
+    .grade-B { color: #f39c12; font-weight: bold; }
+    .grade-C { color: #e74c3c; font-weight: bold; }
+    .grade-D { color: #e67e22; font-weight: bold; }
+    .grade-F { color: #c0392b; font-weight: bold; }
+    .metric-high { background-color: #ffe6e6; }
+    .metric-medium { background-color: #fff3cd; }
+    .metric-low { background-color: #d4edda; }
+    </style>
+    """,
+    unsafe_allow_html=True,
+)
+
+
+def get_grade_color(grade: str) -> str:
+    """Get color for grade"""
+    colors = {
+        "A": "#2ecc71",  # Green
+        "B": "#f39c12",  # Orange
+        "C": "#e74c3c",  # Red
+        "D": "#e67e22",  # Dark Orange
+        "E": "#d35400",  # Darker Orange
+        "F": "#c0392b",  # Dark Red
+    }
+    return colors.get(grade, "#95a5a6")
+
+
+def get_complexity_color(complexity: int, high_threshold: int = 10) -> str:
+    """Get color based on complexity value"""
+    if complexity <= 3:
+        return "#2ecc71"  # Green - Simple
+    elif complexity <= 7:
+        return "#f39c12"  # Orange - Moderate
+    elif complexity <= high_threshold:
+        return "#e74c3c"  # Red - Complex
+    else:
+        return "#c0392b"  # Dark Red - Very Complex
+
+
+def flatten_report(report: Dict[str, List[Dict]]) -> pd.DataFrame:
+    """Convert nested JSON report to flattened DataFrame"""
+    rows = []
+
+    for filepath, items in report.items():
+        if not isinstance(items, list):
+            continue
+
+        for item in items:
+            row = {
+                "filepath": filepath,
+                "type": item.get("type", "N/A"),
+                "name": item.get("name", "N/A"),
+                "classname": item.get("classname", ""),
+                "complexity": item.get("complexity", 0),
+                "rank": item.get("rank", "N/A"),
+                "lineno": item.get("lineno", 0),
+                "endline": item.get("endline", 0),
+                "col_offset": item.get("col_offset", 0),
+            }
+            rows.append(row)
+
+            # Add nested methods/closures
+            if item.get("methods"):
+                for method in item["methods"]:
+                    method_row = row.copy()
+                    method_row.update(
+                        {
+                            "type": method.get("type", "method"),
+                            "name": method.get("name", "N/A"),
+                            "complexity": method.get("complexity", 0),
+                            "rank": method.get("rank", "N/A"),
+                            "lineno": method.get("lineno", 0),
+                            "endline": method.get("endline", 0),
+                            "col_offset": method.get("col_offset", 0),
+                            "parent_name": item.get("name", ""),
+                        }
+                    )
+                    rows.append(method_row)
+
+            if item.get("closures"):
+                for closure in item["closures"]:
+                    closure_row = row.copy()
+                    closure_row.update(
+                        {
+                            "type": closure.get("type", "closure"),
+                            "name": closure.get("name", "N/A"),
+                            "complexity": closure.get("complexity", 0),
+                            "rank": closure.get("rank", "N/A"),
+                            "lineno": closure.get("lineno", 0),
+                            "endline": closure.get("endline", 0),
+                            "col_offset": closure.get("col_offset", 0),
+                            "parent_name": item.get("name", ""),
+                        }
+                    )
+                    rows.append(closure_row)
+
+    return pd.DataFrame(rows)
+
+
+def display_grade_badge(grade: str) -> str:
+    """Create colored grade badge"""
+    color = get_grade_color(grade)
+    return f'<span style="background-color: {color}; color: white; padding: 4px 8px; border-radius: 4px; font-weight: bold;">{grade}</span>'
+
+
+def identify_risky_items(
+    df: pd.DataFrame, complexity_threshold: int = 10, risky_grades: List[str] = None
+) -> pd.DataFrame:
+    """Identify items that need investigation"""
+    if risky_grades is None:
+        risky_grades = ["D", "E", "F"]
+
+    risky = df[
+        (df["complexity"] >= complexity_threshold) | (df["rank"].isin(risky_grades))
+    ]
+    return risky.sort_values("complexity", ascending=False)
+
+
+def create_complexity_chart(df: pd.DataFrame):
+    """Create a chart showing complexity distribution"""
+    complexity_dist = df["complexity"].value_counts().sort_index()
+    fig = go.Figure(data=[go.Bar(x=complexity_dist.index, y=complexity_dist.values)])
+    fig.update_layout(
+        title="Complexity Distribution",
+        xaxis_title="Complexity Level",
+        yaxis_title="Count",
+        hovermode="x unified",
+    )
+    return fig
+
+
+def create_grade_chart(df: pd.DataFrame):
+    """Create a chart showing grade distribution"""
+    grade_dist = df["rank"].value_counts()
+    grade_order = ["A", "B", "C", "D", "E", "F"]
+    grade_dist = grade_dist.reindex(
+        [g for g in grade_order if g in grade_dist.index], fill_value=0
+    )
+
+    colors = [get_grade_color(g) for g in grade_dist.index]
+    fig = go.Figure(
+        data=[go.Bar(x=grade_dist.index, y=grade_dist.values, marker_color=colors)]
+    )
+    fig.update_layout(
+        title="Grade Distribution",
+        xaxis_title="Grade",
+        yaxis_title="Count",
+        hovermode="x unified",
+    )
+    return fig
+
+
+def create_scatter_plot(df: pd.DataFrame):
+    """Create scatter plot of complexity vs files"""
+    # Add a column with just the filename for display
+    df_plot = df.copy()
+    df_plot["filename"] = df_plot["filepath"].apply(lambda x: x.split("/")[-1])
+
+    fig = px.scatter(
+        df_plot,
+        x="filename",
+        y="complexity",
+        color="rank",
+        hover_data=["name", "type", "lineno", "filepath"],
+        title="Complexity by File and Grade",
+        color_discrete_map={g: get_grade_color(g) for g in df_plot["rank"].unique()},
+        height=600,
+    )
+    fig.update_layout(xaxis_tickangle=-45, xaxis_title="File")
+    return fig
+
+
+# Initialize session state
+if "report_data" not in st.session_state:
+    st.session_state.report_data = None
+if "df" not in st.session_state:
+    st.session_state.df = None
+
+# Sidebar for file upload
+st.sidebar.title("📊 Radon Report Analyzer")
+
+# File upload
+uploaded_file = st.sidebar.file_uploader(
+    "Upload JSON Report",
+    type=["json"],
+    help="Upload the cyclomatic complexity report from radon library",
+)
+
+if uploaded_file:
+    try:
+        report_data = json.load(uploaded_file)
+        st.session_state.report_data = report_data
+        st.session_state.df = flatten_report(report_data)
+        st.sidebar.success("✅ Report loaded successfully!")
+    except json.JSONDecodeError:
+        st.sidebar.error("❌ Invalid JSON file")
+    except Exception as e:
+        st.sidebar.error(f"❌ Error loading file: {str(e)}")
+
+# Main app logic
+if st.session_state.df is not None and len(st.session_state.df) > 0:
+    df = st.session_state.df.copy()
+
+    # drop duplicate rows by name (drop the one with NaN parrent)
+    df = df.drop_duplicates(subset=["name", "filepath", "lineno"], keep="first")
+
+    # Create tabs
+    tab1, tab2, tab3, tab4 = st.tabs(
+        ["📈 Overview", "🔍 Analysis", "⚠️ Warnings", "📋 Details"]
+    )
+
+    # ===== TAB 1: OVERVIEW =====
+    with tab1:
+        col1, col2, col3, col4 = st.columns(4)
+
+        with col1:
+            st.metric("Total Items", len(df))
+        with col2:
+            st.metric("Total Files", df["filepath"].nunique())
+        with col3:
+            avg_complexity = df["complexity"].mean()
+            st.metric("Avg Complexity", f"{avg_complexity:.2f}")
+        with col4:
+            max_complexity = df["complexity"].max()
+            st.metric("Max Complexity", max_complexity)
+
+        st.divider()
+
+        col1, col2 = st.columns(2)
+        with col1:
+            st.plotly_chart(create_complexity_chart(df), use_container_width=True)
+        with col2:
+            st.plotly_chart(create_grade_chart(df), use_container_width=True)
+
+        st.divider()
+        st.subheader("📍 Complexity by File and Grade")
+
+        # File filter for scatter plot - show only filename, not full path
+        filepath_to_filename = {fp: fp.split("/")[-1] for fp in df["filepath"].unique()}
+        filename_to_filepath = {v: k for k, v in filepath_to_filename.items()}
+
+        # Initialize selected files in session state if not exists
+        if "selected_scatter_files" not in st.session_state:
+            st.session_state.selected_scatter_files = sorted(
+                filepath_to_filename.values()
+            )
+
+        # Select all / Remove all buttons
+        col_btn1, col_btn2, col_spacer = st.columns([1, 1, 6])
+        with col_btn1:
+            if st.button("Select All", use_container_width=True):
+                st.session_state.selected_scatter_files = sorted(
+                    filepath_to_filename.values()
+                )
+                st.rerun()
+        with col_btn2:
+            if st.button("Remove All", use_container_width=True):
+                st.session_state.selected_scatter_files = []
+                st.rerun()
+
+        st.write("**Select files to display:**")
+        scatter_file_filter_display = st.pills(
+            "Filter files",
+            options=sorted(filepath_to_filename.values()),
+            selection_mode="multi",
+            default=st.session_state.selected_scatter_files,
+            label_visibility="collapsed",
+            key="scatter_plot_file_filter",
+        )
+
+        # Update session state
+        st.session_state.selected_scatter_files = (
+            scatter_file_filter_display if scatter_file_filter_display else []
+        )
+
+        # Convert selected filenames back to full paths
+        scatter_file_filter = [
+            filename_to_filepath[fn] for fn in (scatter_file_filter_display or [])
+        ]
+
+        # Apply file filter for scatter plot
+        if scatter_file_filter:
+            scatter_df = df[df["filepath"].isin(scatter_file_filter)]
+        else:
+            scatter_df = pd.DataFrame()  # Empty dataframe when no files selected
+
+        if len(scatter_df) > 0:
+            st.plotly_chart(create_scatter_plot(scatter_df), use_container_width=True)
+        else:
+            st.info("No data to display. Please select at least one file.")
+
+    # ===== TAB 2: ANALYSIS WITH FILTERS =====
+    with tab2:
+        st.subheader("Filter & Sort Data")
+
+        col1, col2, col3, col4 = st.columns(4)
+
+        with col1:
+            type_filter = st.multiselect(
+                "Type",
+                options=df["type"].unique(),
+                default=df["type"].unique(),
+                help="Filter by item type",
+            )
+
+        with col2:
+            grade_filter = st.multiselect(
+                "Grade",
+                options=sorted(df["rank"].unique()),
+                default=sorted(df["rank"].unique()),
+                help="Filter by grade",
+            )
+
+        with col3:
+            complexity_range = st.slider(
+                "Complexity Range",
+                min_value=int(df["complexity"].min()),
+                max_value=int(df["complexity"].max()),
+                value=(int(df["complexity"].min()), int(df["complexity"].max())),
+                help="Filter by complexity level",
+            )
+
+        with col4:
+            filepath_filter = st.multiselect(
+                "Files",
+                options=sorted(df["filepath"].unique()),
+                default=sorted(df["filepath"].unique()),
+                help="Filter by file",
+            )
+
+        # Apply filters
+        filtered_df = df[
+            (df["type"].isin(type_filter))
+            & (df["rank"].isin(grade_filter))
+            & (df["complexity"] >= complexity_range[0])
+            & (df["complexity"] <= complexity_range[1])
+            & (df["filepath"].isin(filepath_filter))
+        ]
+
+        col1, col2 = st.columns(2)
+        with col1:
+            sort_by = st.selectbox(
+                "Sort by",
+                options=[
+                    "Complexity (High→Low)",
+                    "Complexity (Low→High)",
+                    "Grade (Best→Worst)",
+                    "Name (A→Z)",
+                    "File Path",
+                    "Line Number",
+                ],
+                help="Sort the filtered results",
+            )
+
+        with col2:
+            search_term = st.text_input(
+                "Search by name", help="Search for specific function/class names"
+            )
+
+        # Apply sorting
+        if sort_by == "Complexity (High→Low)":
+            filtered_df = filtered_df.sort_values("complexity", ascending=False)
+        elif sort_by == "Complexity (Low→High)":
+            filtered_df = filtered_df.sort_values("complexity", ascending=True)
+        elif sort_by == "Grade (Best→Worst)":
+            grade_order = {"A": 1, "B": 2, "C": 3, "D": 4, "F": 5}
+            filtered_df = filtered_df.sort_values(
+                "rank", key=lambda x: x.map(grade_order)
+            )
+        elif sort_by == "Name (A→Z)":
+            filtered_df = filtered_df.sort_values("name")
+        elif sort_by == "File Path":
+            filtered_df = filtered_df.sort_values("filepath")
+        elif sort_by == "Line Number":
+            filtered_df = filtered_df.sort_values("lineno")
+
+        # Apply search
+        if search_term:
+            filtered_df = filtered_df[
+                filtered_df["name"].str.contains(search_term, case=False, na=False)
+            ]
+
+        st.info(f"Showing {len(filtered_df)} of {len(df)} items")
+
+        # Display table with color coding
+        def style_dataframe(val, column):
+            if column == "rank":
+                color = get_grade_color(val)
+                return f"background-color: {color}; color: white; font-weight: bold;"
+            elif column == "complexity":
+                color = get_complexity_color(int(val))
+                return f"background-color: {color}; color: white;"
+            return ""
+
+        display_df = filtered_df[
+            ["filepath", "type", "name", "complexity", "rank", "lineno", "endline"]
+        ].copy()
+        display_df = display_df.reset_index(drop=True)
+
+        st.dataframe(
+            display_df,
+            use_container_width=True,
+            column_config={
+                "complexity": st.column_config.NumberColumn(width="small"),
+                "rank": st.column_config.TextColumn(width="small"),
+                "lineno": st.column_config.NumberColumn(width="small"),
+                "endline": st.column_config.NumberColumn(width="small"),
+                "type": st.column_config.TextColumn(width="small"),
+            },
+        )
+
+    # ===== TAB 3: WARNINGS =====
+    with tab3:
+        st.subheader("⚠️ Items Requiring Investigation")
+
+        col1, col2 = st.columns(2)
+        with col1:
+            complexity_threshold = st.slider(
+                "Complexity Threshold",
+                min_value=1,
+                max_value=int(df["complexity"].max()),
+                value=10,
+                help="Items with complexity >= this value will be flagged",
+            )
+
+        with col2:
+            risky_grades = st.multiselect(
+                "Risky Grades",
+                options=["A", "B", "C", "D", "E", "F"],
+                default=["D", "E", "F"],
+                help="Grades considered risky",
+            )
+
+        risky_df = identify_risky_items(df, complexity_threshold, risky_grades)
+
+        if len(risky_df) > 0:
+            st.warning(f"⚠️ Found {len(risky_df)} items that need investigation")
+
+            # Group by severity
+            col1, col2 = st.columns(2)
+            with col1:
+                high_risk = risky_df[risky_df["complexity"] >= complexity_threshold + 5]
+                st.metric("High Risk (Very High Complexity)", len(high_risk))
+
+            with col2:
+                bad_grade = risky_df[risky_df["rank"].isin(["D", "F"])]
+                st.metric("Bad Grade Items", len(bad_grade))
+
+            st.divider()
+
+            # Detailed view of risky items
+            for idx, (_, row) in enumerate(risky_df.head(20).iterrows(), 1):
+                with st.expander(
+                    f"🚨 {row['name']} (Complexity: {row['complexity']}, Grade: {row['rank']})",
+                    expanded=(idx == 1),
+                ):
+                    col1, col2, col3, col4 = st.columns(4)
+                    with col1:
+                        st.metric("Complexity", row["complexity"])
+                    with col2:
+                        st.write(f"**Grade:** {row['rank']}")
+                    with col3:
+                        st.write(f"**Type:** {row['type']}")
+                    with col4:
+                        st.write(f"**Lines:** {row['lineno']}-{row['endline']}")
+
+                    st.write(f"**File:** `{row['filepath']}`")
+                    full_name = (
+                        f"{row['classname']}.{row['name']}"
+                        if row["type"] == "method"
+                        else row["name"]
+                    )
+                    st.write(f"**Full Name:** `{full_name}`")
+
+                    # Recommendation
+                    if row["complexity"] >= complexity_threshold + 5:
+                        st.error("🔴 **CRITICAL:** This needs immediate refactoring")
+                    elif row["complexity"] >= complexity_threshold:
+                        st.warning(
+                            "🟠 **HIGH:** Consider breaking this into smaller functions"
+                        )
+
+                    if row["rank"] in ["D", "E", "F"]:
+                        st.warning(
+                            f"**Grade {row['rank']}:** Code quality is poor, refactoring recommended"
+                        )
+        else:
+            st.success("✅ No risky items found! Your code looks good.")
+
+    # ===== TAB 4: DETAILED VIEW =====
+    with tab4:
+        st.subheader("Detailed Item Analysis")
+
+        # Select item to analyze
+        df_display = df.copy()
+        df_display["display_name"] = df_display.apply(
+            lambda x: f"{x['name']} ({x['type']}) - {x['filepath'].split('/')[-1]}",
+            axis=1,
+        )
+
+        selected_item = st.selectbox(
+            "Select an item to analyze",
+            options=df_display.index,
+            format_func=lambda x: df_display.loc[x, "display_name"],
+        )
+
+        if selected_item is not None:
+            item = df.iloc[selected_item]
+
+            # Header with grade badge
+            col1, col2 = st.columns([3, 1])
+            with col1:
+                st.title(item["name"])
+            with col2:
+                grade_html = display_grade_badge(item["rank"])
+                st.markdown(grade_html, unsafe_allow_html=True)
+
+            st.divider()
+
+            # Detailed metrics
+            col1, col2, col3, col4, col5 = st.columns(5)
+            with col1:
+                st.metric("Complexity", item["complexity"])
+            with col2:
+                st.metric("Type", item["type"])
+            with col3:
+                st.metric("Start Line", int(item["lineno"]))
+            with col4:
+                st.metric("End Line", int(item["endline"]))
+            with col5:
+                st.metric("Lines of Code", int(item["endline"] - item["lineno"] + 1))
+
+            st.divider()
+
+            # File and location info
+            col1, col2 = st.columns(2)
+            with col1:
+                st.write("**File Path:**")
+                st.code(item["filepath"], language="text")
+            with col2:
+                st.write("**Location:**")
+                st.code(
+                    f"Line {int(item['lineno'])} to {int(item['endline'])}, Column {int(item['col_offset'])}",
+                    language="text",
+                )
+
+            if item["classname"]:
+                st.write("**Class Name:**")
+                st.code(item["classname"], language="text")
+
+            st.divider()
+
+            # Recommendations
+            st.subheader("💡 Recommendations")
+
+            complexity = int(item["complexity"])
+            if complexity <= 3:
+                st.success(
+                    "✅ **Simple:** This code is easy to understand and maintain."
+                )
+            elif complexity <= 7:
+                st.info(
+                    "ℹ️ **Moderate:** Code is reasonably complex. Consider breaking into smaller functions if it exceeds 7."
+                )
+            elif complexity <= 10:
+                st.warning(
+                    "⚠️ **Complex:** This code is complex and may be difficult to maintain. Consider refactoring."
+                )
+            else:
+                st.error(
+                    "🔴 **Very Complex:** This code needs immediate refactoring. Break it into smaller, testable units."
+                )
+
+            if item["rank"] in ["D", "E", "F"]:
+                st.error(
+                    f"📉 **Grade {item['rank']}:** Code quality needs improvement."
+                )
+
+else:
+    # Landing page
+    st.title("📊 Radon Complexity Analyzer")
+    st.markdown(
+        """
+    Welcome to the Radon Cyclomatic Complexity Analyzer!
+
+    This tool helps you analyze and visualize Python code complexity reports from the **radon** library.
+
+    ### Features:
+    - 📈 **Overview:** See complexity distribution across your codebase
+    - 🔍 **Analysis:** Filter, sort, and search for specific functions/classes
+    - ⚠️ **Warnings:** Identify items that need immediate attention
+    - 📋 **Details:** Get detailed analysis and recommendations for each item
+
+    ### How to use:
+    1. Generate a radon complexity report as JSON:
+       ```bash
+       radon cc your_project/ -j > report.json
+       ```
+    2. Upload the JSON file using the sidebar
+    3. Explore and analyze your code complexity!
+    """
+    )
+
+    # Create sample data for demonstration
+    st.divider()
+    st.subheader("Or try with sample data:")
+
+    if st.button("Load Sample Report"):
+        sample_report = {
+            "example/settings.py": [
+                {
+                    "type": "class",
+                    "rank": "A",
+                    "lineno": 7,
+                    "complexity": 1,
+                    "endline": 8,
+                    "name": "DBSettings",
+                    "col_offset": 0,
+                    "methods": [],
+                },
+                {
+                    "type": "class",
+                    "rank": "B",
+                    "lineno": 11,
+                    "complexity": 5,
+                    "endline": 13,
+                    "name": "ComplexSettings",
+                    "col_offset": 0,
+                    "methods": [
+                        {
+                            "type": "method",
+                            "rank": "C",
+                            "lineno": 12,
+                            "classname": "ComplexSettings",
+                            "complexity": 8,
+                            "endline": 13,
+                            "name": "validate",
+                            "col_offset": 4,
+                            "closures": [],
+                        }
+                    ],
+                },
+            ],
+            "example/base.py": [
+                {
+                    "type": "function",
+                    "rank": "F",
+                    "lineno": 1,
+                    "complexity": 15,
+                    "endline": 50,
+                    "name": "complex_function",
+                    "col_offset": 0,
+                }
+            ],
+        }
+
+        st.session_state.report_data = sample_report
+        st.session_state.df = flatten_report(sample_report)
+        st.success("✅ Sample data loaded! Refresh the page to see the analysis.")
+        st.rerun()

requirements.txt

@@ -0,0 +1,4 @@
+altair
+streamlit==1.40.0
+pandas
+plotly==5.17.0

src/sample_report.json

@@ -0,0 +1,308 @@
+{
+    "project/config/settings.py": [
+        {
+            "type": "class",
+            "rank": "A",
+            "lineno": 5,
+            "complexity": 1,
+            "endline": 8,
+            "name": "DatabaseConfig",
+            "col_offset": 0,
+            "methods": []
+        },
+        {
+            "type": "class",
+            "rank": "A",
+            "lineno": 12,
+            "complexity": 2,
+            "endline": 18,
+            "name": "AppConfig",
+            "col_offset": 0,
+            "methods": []
+        },
+        {
+            "type": "function",
+            "rank": "A",
+            "lineno": 22,
+            "complexity": 3,
+            "endline": 28,
+            "name": "load_settings",
+            "col_offset": 0
+        }
+    ],
+    "project/core/base.py": [
+        {
+            "type": "class",
+            "rank": "B",
+            "lineno": 10,
+            "complexity": 5,
+            "endline": 85,
+            "name": "BaseHandler",
+            "col_offset": 0,
+            "methods": [
+                {
+                    "type": "method",
+                    "rank": "A",
+                    "lineno": 15,
+                    "classname": "BaseHandler",
+                    "complexity": 1,
+                    "endline": 25,
+                    "name": "__init__",
+                    "col_offset": 4,
+                    "closures": []
+                },
+                {
+                    "type": "method",
+                    "rank": "B",
+                    "lineno": 27,
+                    "classname": "BaseHandler",
+                    "complexity": 5,
+                    "endline": 45,
+                    "name": "validate_input",
+                    "col_offset": 4,
+                    "closures": []
+                },
+                {
+                    "type": "method",
+                    "rank": "A",
+                    "lineno": 47,
+                    "classname": "BaseHandler",
+                    "complexity": 2,
+                    "endline": 55,
+                    "name": "process",
+                    "col_offset": 4,
+                    "closures": []
+                }
+            ]
+        }
+    ],
+    "project/utils/data_sampler.py": [
+        {
+            "type": "class",
+            "rank": "A",
+            "lineno": 1,
+            "complexity": 2,
+            "endline": 50,
+            "name": "sample_data",
+            "col_offset": 0,
+            "methods": [
+                {
+                    "type": "method",
+                    "rank": "A",
+                    "lineno": 5,
+                    "classname": "Sampler",
+                    "complexity": 2,
+                    "endline": 20,
+                    "name": "Sample",
+                    "col_offset": 4,
+                    "closures": []
+                }
+            ]
+        }
+    ],
+    "project/utils/data_processor.py": [
+        {
+            "type": "function",
+            "rank": "C",
+            "lineno": 5,
+            "complexity": 8,
+            "endline": 45,
+            "name": "validate_data",
+            "col_offset": 0
+        },
+        {
+            "type": "function",
+            "rank": "D",
+            "lineno": 50,
+            "complexity": 12,
+            "endline": 120,
+            "name": "process_complex_data",
+            "col_offset": 0,
+            "closures": [
+                {
+                    "type": "function",
+                    "rank": "B",
+                    "lineno": 65,
+                    "complexity": 5,
+                    "endline": 85,
+                    "name": "filter_items",
+                    "col_offset": 4,
+                    "closures": []
+                },
+                {
+                    "type": "function",
+                    "rank": "C",
+                    "lineno": 90,
+                    "complexity": 7,
+                    "endline": 110,
+                    "name": "transform_items",
+                    "col_offset": 4,
+                    "closures": []
+                }
+            ]
+        }
+    ],
+    "project/legacy/old_parser.py": [
+        {
+            "type": "function",
+            "rank": "F",
+            "lineno": 10,
+            "complexity": 22,
+            "endline": 150,
+            "name": "legacy_xml_parser",
+            "col_offset": 0
+        },
+        {
+            "type": "function",
+            "rank": "E",
+            "lineno": 155,
+            "complexity": 15,
+            "endline": 220,
+            "name": "migrate_old_format",
+            "col_offset": 0
+        },
+        {
+            "type": "class",
+            "rank": "D",
+            "lineno": 225,
+            "complexity": 11,
+            "endline": 350,
+            "name": "LegacyHandler",
+            "col_offset": 0,
+            "methods": [
+                {
+                    "type": "method",
+                    "rank": "D",
+                    "lineno": 230,
+                    "classname": "LegacyHandler",
+                    "complexity": 11,
+                    "endline": 280,
+                    "name": "parse_config",
+                    "col_offset": 4,
+                    "closures": []
+                },
+                {
+                    "type": "method",
+                    "rank": "C",
+                    "lineno": 285,
+                    "classname": "LegacyHandler",
+                    "complexity": 9,
+                    "endline": 320,
+                    "name": "convert_format",
+                    "col_offset": 4,
+                    "closures": []
+                }
+            ]
+        }
+    ],
+    "project/api/handlers.py": [
+        {
+            "type": "function",
+            "rank": "B",
+            "lineno": 8,
+            "complexity": 6,
+            "endline": 25,
+            "name": "handle_request",
+            "col_offset": 0
+        },
+        {
+            "type": "function",
+            "rank": "A",
+            "lineno": 30,
+            "complexity": 4,
+            "endline": 40,
+            "name": "validate_token",
+            "col_offset": 0
+        },
+        {
+            "type": "class",
+            "rank": "C",
+            "lineno": 45,
+            "complexity": 8,
+            "endline": 120,
+            "name": "APIHandler",
+            "col_offset": 0,
+            "methods": [
+                {
+                    "type": "method",
+                    "rank": "B",
+                    "lineno": 50,
+                    "classname": "APIHandler",
+                    "complexity": 5,
+                    "endline": 70,
+                    "name": "authenticate",
+                    "col_offset": 4,
+                    "closures": []
+                },
+                {
+                    "type": "method",
+                    "rank": "C",
+                    "lineno": 75,
+                    "classname": "APIHandler",
+                    "complexity": 8,
+                    "endline": 100,
+                    "name": "process_request",
+                    "col_offset": 4,
+                    "closures": []
+                },
+                {
+                    "type": "method",
+                    "rank": "A",
+                    "lineno": 105,
+                    "classname": "APIHandler",
+                    "complexity": 3,
+                    "endline": 115,
+                    "name": "send_response",
+                    "col_offset": 4,
+                    "closures": []
+                }
+            ]
+        }
+    ],
+    "project/models/user.py": [
+        {
+            "type": "class",
+            "rank": "B",
+            "lineno": 5,
+            "complexity": 6,
+            "endline": 80,
+            "name": "User",
+            "col_offset": 0,
+            "methods": [
+                {
+                    "type": "method",
+                    "rank": "A",
+                    "lineno": 10,
+                    "classname": "User",
+                    "complexity": 1,
+                    "endline": 20,
+                    "name": "__init__",
+                    "col_offset": 4,
+                    "closures": []
+                },
+                {
+                    "type": "method",
+                    "rank": "B",
+                    "lineno": 25,
+                    "classname": "User",
+                    "complexity": 6,
+                    "endline": 50,
+                    "name": "update_profile",
+                    "col_offset": 4,
+                    "closures": []
+                },
+                {
+                    "type": "method",
+                    "rank": "A",
+                    "lineno": 55,
+                    "classname": "User",
+                    "complexity": 2,
+                    "endline": 65,
+                    "name": "is_active",
+                    "col_offset": 4,
+                    "closures": []
+                }
+            ]
+        }
+    ]
+}

src/streamlit_app.py

@@ -0,0 +1,680 @@
+import json
+from pathlib import Path
+from typing import Any, Dict, List
+
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objects as go
+import streamlit as st
+
+st.set_page_config(
+    page_title="Radon Complexity Analyzer",
+    page_icon="📊",
+    layout="wide",
+    initial_sidebar_state="expanded",
+)
+
+# Custom CSS for better styling
+st.markdown(
+    """
+    <style>
+    .grade-A { color: #2ecc71; font-weight: bold; }
+    .grade-B { color: #f39c12; font-weight: bold; }
+    .grade-C { color: #e74c3c; font-weight: bold; }
+    .grade-D { color: #e67e22; font-weight: bold; }
+    .grade-F { color: #c0392b; font-weight: bold; }
+    .metric-high { background-color: #ffe6e6; }
+    .metric-medium { background-color: #fff3cd; }
+    .metric-low { background-color: #d4edda; }
+    </style>
+    """,
+    unsafe_allow_html=True,
+)
+
+
+def get_grade_color(grade: str) -> str:
+    """Get color for grade"""
+    colors = {
+        "A": "#2ecc71",  # Green
+        "B": "#f39c12",  # Orange
+        "C": "#e74c3c",  # Red
+        "D": "#e67e22",  # Dark Orange
+        "E": "#d35400",  # Darker Orange
+        "F": "#c0392b",  # Dark Red
+    }
+    return colors.get(grade, "#95a5a6")
+
+
+def get_complexity_color(complexity: int, high_threshold: int = 10) -> str:
+    """Get color based on complexity value"""
+    if complexity <= 3:
+        return "#2ecc71"  # Green - Simple
+    elif complexity <= 7:
+        return "#f39c12"  # Orange - Moderate
+    elif complexity <= high_threshold:
+        return "#e74c3c"  # Red - Complex
+    else:
+        return "#c0392b"  # Dark Red - Very Complex
+
+
+def flatten_report(report: Dict[str, List[Dict]]) -> pd.DataFrame:
+    """Convert nested JSON report to flattened DataFrame"""
+    rows = []
+
+    for filepath, items in report.items():
+        if not isinstance(items, list):
+            continue
+
+        for item in items:
+            row = {
+                "filepath": filepath,
+                "type": item.get("type", "N/A"),
+                "name": item.get("name", "N/A"),
+                "classname": item.get("classname", ""),
+                "complexity": item.get("complexity", 0),
+                "rank": item.get("rank", "N/A"),
+                "lineno": item.get("lineno", 0),
+                "endline": item.get("endline", 0),
+                "col_offset": item.get("col_offset", 0),
+            }
+            rows.append(row)
+
+            # Add nested methods/closures
+            if item.get("methods"):
+                for method in item["methods"]:
+                    method_row = row.copy()
+                    method_row.update(
+                        {
+                            "type": method.get("type", "method"),
+                            "name": method.get("name", "N/A"),
+                            "complexity": method.get("complexity", 0),
+                            "rank": method.get("rank", "N/A"),
+                            "lineno": method.get("lineno", 0),
+                            "endline": method.get("endline", 0),
+                            "col_offset": method.get("col_offset", 0),
+                            "parent_name": item.get("name", ""),
+                        }
+                    )
+                    rows.append(method_row)
+
+            if item.get("closures"):
+                for closure in item["closures"]:
+                    closure_row = row.copy()
+                    closure_row.update(
+                        {
+                            "type": closure.get("type", "closure"),
+                            "name": closure.get("name", "N/A"),
+                            "complexity": closure.get("complexity", 0),
+                            "rank": closure.get("rank", "N/A"),
+                            "lineno": closure.get("lineno", 0),
+                            "endline": closure.get("endline", 0),
+                            "col_offset": closure.get("col_offset", 0),
+                            "parent_name": item.get("name", ""),
+                        }
+                    )
+                    rows.append(closure_row)
+
+    return pd.DataFrame(rows)
+
+
+def display_grade_badge(grade: str) -> str:
+    """Create colored grade badge"""
+    color = get_grade_color(grade)
+    return f'<span style="background-color: {color}; color: white; padding: 4px 8px; border-radius: 4px; font-weight: bold;">{grade}</span>'
+
+
+def identify_risky_items(
+    df: pd.DataFrame, complexity_threshold: int = 10, risky_grades: List[str] = None
+) -> pd.DataFrame:
+    """Identify items that need investigation"""
+    if risky_grades is None:
+        risky_grades = ["D", "E", "F"]
+
+    risky = df[
+        (df["complexity"] >= complexity_threshold) | (df["rank"].isin(risky_grades))
+    ]
+    return risky.sort_values("complexity", ascending=False)
+
+
+def create_complexity_chart(df: pd.DataFrame):
+    """Create a chart showing complexity distribution"""
+    complexity_dist = df["complexity"].value_counts().sort_index()
+    fig = go.Figure(data=[go.Bar(x=complexity_dist.index, y=complexity_dist.values)])
+    fig.update_layout(
+        title="Complexity Distribution",
+        xaxis_title="Complexity Level",
+        yaxis_title="Count",
+        hovermode="x unified",
+    )
+    return fig
+
+
+def create_grade_chart(df: pd.DataFrame):
+    """Create a chart showing grade distribution"""
+    grade_dist = df["rank"].value_counts()
+    grade_order = ["A", "B", "C", "D", "E", "F"]
+    grade_dist = grade_dist.reindex(
+        [g for g in grade_order if g in grade_dist.index], fill_value=0
+    )
+
+    colors = [get_grade_color(g) for g in grade_dist.index]
+    fig = go.Figure(
+        data=[go.Bar(x=grade_dist.index, y=grade_dist.values, marker_color=colors)]
+    )
+    fig.update_layout(
+        title="Grade Distribution",
+        xaxis_title="Grade",
+        yaxis_title="Count",
+        hovermode="x unified",
+    )
+    return fig
+
+
+def create_scatter_plot(df: pd.DataFrame):
+    """Create scatter plot of complexity vs files"""
+    # Add a column with just the filename for display
+    df_plot = df.copy()
+    df_plot["filename"] = df_plot["filepath"].apply(lambda x: x.split("/")[-1])
+
+    fig = px.scatter(
+        df_plot,
+        x="filename",
+        y="complexity",
+        color="rank",
+        hover_data=["name", "type", "lineno", "filepath"],
+        title="Complexity by File and Grade",
+        color_discrete_map={g: get_grade_color(g) for g in df_plot["rank"].unique()},
+        height=600,
+    )
+    fig.update_layout(xaxis_tickangle=-45, xaxis_title="File")
+    return fig
+
+
+# Initialize session state
+if "report_data" not in st.session_state:
+    st.session_state.report_data = None
+if "df" not in st.session_state:
+    st.session_state.df = None
+
+# Sidebar for file upload
+st.sidebar.title("📊 Radon Report Analyzer")
+
+# File upload
+uploaded_file = st.sidebar.file_uploader(
+    "Upload JSON Report",
+    type=["json"],
+    help="Upload the cyclomatic complexity report from radon library",
+)
+
+if uploaded_file:
+    try:
+        report_data = json.load(uploaded_file)
+        st.session_state.report_data = report_data
+        st.session_state.df = flatten_report(report_data)
+        st.sidebar.success("✅ Report loaded successfully!")
+    except json.JSONDecodeError:
+        st.sidebar.error("❌ Invalid JSON file")
+    except Exception as e:
+        st.sidebar.error(f"❌ Error loading file: {str(e)}")
+
+# Main app logic
+if st.session_state.df is not None and len(st.session_state.df) > 0:
+    df = st.session_state.df.copy()
+
+    # drop duplicate rows by name (drop the one with NaN parrent)
+    df = df.drop_duplicates(subset=["name", "filepath", "lineno"], keep="first")
+
+    # Create tabs
+    tab1, tab2, tab3, tab4 = st.tabs(
+        ["📈 Overview", "🔍 Analysis", "⚠️ Warnings", "📋 Details"]
+    )
+
+    # ===== TAB 1: OVERVIEW =====
+    with tab1:
+        col1, col2, col3, col4 = st.columns(4)
+
+        with col1:
+            st.metric("Total Items", len(df))
+        with col2:
+            st.metric("Total Files", df["filepath"].nunique())
+        with col3:
+            avg_complexity = df["complexity"].mean()
+            st.metric("Avg Complexity", f"{avg_complexity:.2f}")
+        with col4:
+            max_complexity = df["complexity"].max()
+            st.metric("Max Complexity", max_complexity)
+
+        st.divider()
+
+        col1, col2 = st.columns(2)
+        with col1:
+            st.plotly_chart(create_complexity_chart(df), use_container_width=True)
+        with col2:
+            st.plotly_chart(create_grade_chart(df), use_container_width=True)
+
+        st.divider()
+        st.subheader("📍 Complexity by File and Grade")
+
+        # File filter for scatter plot - show only filename, not full path
+        filepath_to_filename = {fp: fp.split("/")[-1] for fp in df["filepath"].unique()}
+        filename_to_filepath = {v: k for k, v in filepath_to_filename.items()}
+
+        # Initialize selected files in session state if not exists
+        if "selected_scatter_files" not in st.session_state:
+            st.session_state.selected_scatter_files = sorted(
+                filepath_to_filename.values()
+            )
+
+        # Select all / Remove all buttons
+        col_btn1, col_btn2, col_spacer = st.columns([1, 1, 6])
+        with col_btn1:
+            if st.button("Select All", use_container_width=True):
+                st.session_state.selected_scatter_files = sorted(
+                    filepath_to_filename.values()
+                )
+                st.rerun()
+        with col_btn2:
+            if st.button("Remove All", use_container_width=True):
+                st.session_state.selected_scatter_files = []
+                st.rerun()
+
+        st.write("**Select files to display:**")
+        scatter_file_filter_display = st.pills(
+            "Filter files",
+            options=sorted(filepath_to_filename.values()),
+            selection_mode="multi",
+            default=st.session_state.selected_scatter_files,
+            label_visibility="collapsed",
+            key="scatter_plot_file_filter",
+        )
+
+        # Update session state
+        st.session_state.selected_scatter_files = (
+            scatter_file_filter_display if scatter_file_filter_display else []
+        )
+
+        # Convert selected filenames back to full paths
+        scatter_file_filter = [
+            filename_to_filepath[fn] for fn in (scatter_file_filter_display or [])
+        ]
+
+        # Apply file filter for scatter plot
+        if scatter_file_filter:
+            scatter_df = df[df["filepath"].isin(scatter_file_filter)]
+        else:
+            scatter_df = pd.DataFrame()  # Empty dataframe when no files selected
+
+        if len(scatter_df) > 0:
+            st.plotly_chart(create_scatter_plot(scatter_df), use_container_width=True)
+        else:
+            st.info("No data to display. Please select at least one file.")
+
+    # ===== TAB 2: ANALYSIS WITH FILTERS =====
+    with tab2:
+        st.subheader("Filter & Sort Data")
+
+        col1, col2, col3, col4 = st.columns(4)
+
+        with col1:
+            type_filter = st.multiselect(
+                "Type",
+                options=df["type"].unique(),
+                default=df["type"].unique(),
+                help="Filter by item type",
+            )
+
+        with col2:
+            grade_filter = st.multiselect(
+                "Grade",
+                options=sorted(df["rank"].unique()),
+                default=sorted(df["rank"].unique()),
+                help="Filter by grade",
+            )
+
+        with col3:
+            complexity_range = st.slider(
+                "Complexity Range",
+                min_value=int(df["complexity"].min()),
+                max_value=int(df["complexity"].max()),
+                value=(int(df["complexity"].min()), int(df["complexity"].max())),
+                help="Filter by complexity level",
+            )
+
+        with col4:
+            filepath_filter = st.multiselect(
+                "Files",
+                options=sorted(df["filepath"].unique()),
+                default=sorted(df["filepath"].unique()),
+                help="Filter by file",
+            )
+
+        # Apply filters
+        filtered_df = df[
+            (df["type"].isin(type_filter))
+            & (df["rank"].isin(grade_filter))
+            & (df["complexity"] >= complexity_range[0])
+            & (df["complexity"] <= complexity_range[1])
+            & (df["filepath"].isin(filepath_filter))
+        ]
+
+        col1, col2 = st.columns(2)
+        with col1:
+            sort_by = st.selectbox(
+                "Sort by",
+                options=[
+                    "Complexity (High→Low)",
+                    "Complexity (Low→High)",
+                    "Grade (Best→Worst)",
+                    "Name (A→Z)",
+                    "File Path",
+                    "Line Number",
+                ],
+                help="Sort the filtered results",
+            )
+
+        with col2:
+            search_term = st.text_input(
+                "Search by name", help="Search for specific function/class names"
+            )
+
+        # Apply sorting
+        if sort_by == "Complexity (High→Low)":
+            filtered_df = filtered_df.sort_values("complexity", ascending=False)
+        elif sort_by == "Complexity (Low→High)":
+            filtered_df = filtered_df.sort_values("complexity", ascending=True)
+        elif sort_by == "Grade (Best→Worst)":
+            grade_order = {"A": 1, "B": 2, "C": 3, "D": 4, "F": 5}
+            filtered_df = filtered_df.sort_values(
+                "rank", key=lambda x: x.map(grade_order)
+            )
+        elif sort_by == "Name (A→Z)":
+            filtered_df = filtered_df.sort_values("name")
+        elif sort_by == "File Path":
+            filtered_df = filtered_df.sort_values("filepath")
+        elif sort_by == "Line Number":
+            filtered_df = filtered_df.sort_values("lineno")
+
+        # Apply search
+        if search_term:
+            filtered_df = filtered_df[
+                filtered_df["name"].str.contains(search_term, case=False, na=False)
+            ]
+
+        st.info(f"Showing {len(filtered_df)} of {len(df)} items")
+
+        # Display table with color coding
+        def style_dataframe(val, column):
+            if column == "rank":
+                color = get_grade_color(val)
+                return f"background-color: {color}; color: white; font-weight: bold;"
+            elif column == "complexity":
+                color = get_complexity_color(int(val))
+                return f"background-color: {color}; color: white;"
+            return ""
+
+        display_df = filtered_df[
+            ["filepath", "type", "name", "complexity", "rank", "lineno", "endline"]
+        ].copy()
+        display_df = display_df.reset_index(drop=True)
+
+        st.dataframe(
+            display_df,
+            use_container_width=True,
+            column_config={
+                "complexity": st.column_config.NumberColumn(width="small"),
+                "rank": st.column_config.TextColumn(width="small"),
+                "lineno": st.column_config.NumberColumn(width="small"),
+                "endline": st.column_config.NumberColumn(width="small"),
+                "type": st.column_config.TextColumn(width="small"),
+            },
+        )
+
+    # ===== TAB 3: WARNINGS =====
+    with tab3:
+        st.subheader("⚠️ Items Requiring Investigation")
+
+        col1, col2 = st.columns(2)
+        with col1:
+            complexity_threshold = st.slider(
+                "Complexity Threshold",
+                min_value=1,
+                max_value=int(df["complexity"].max()),
+                value=10,
+                help="Items with complexity >= this value will be flagged",
+            )
+
+        with col2:
+            risky_grades = st.multiselect(
+                "Risky Grades",
+                options=["A", "B", "C", "D", "E", "F"],
+                default=["D", "E", "F"],
+                help="Grades considered risky",
+            )
+
+        risky_df = identify_risky_items(df, complexity_threshold, risky_grades)
+
+        if len(risky_df) > 0:
+            st.warning(f"⚠️ Found {len(risky_df)} items that need investigation")
+
+            # Group by severity
+            col1, col2 = st.columns(2)
+            with col1:
+                high_risk = risky_df[risky_df["complexity"] >= complexity_threshold + 5]
+                st.metric("High Risk (Very High Complexity)", len(high_risk))
+
+            with col2:
+                bad_grade = risky_df[risky_df["rank"].isin(["D", "F"])]
+                st.metric("Bad Grade Items", len(bad_grade))
+
+            st.divider()
+
+            # Detailed view of risky items
+            for idx, (_, row) in enumerate(risky_df.head(20).iterrows(), 1):
+                with st.expander(
+                    f"🚨 {row['name']} (Complexity: {row['complexity']}, Grade: {row['rank']})",
+                    expanded=(idx == 1),
+                ):
+                    col1, col2, col3, col4 = st.columns(4)
+                    with col1:
+                        st.metric("Complexity", row["complexity"])
+                    with col2:
+                        st.write(f"**Grade:** {row['rank']}")
+                    with col3:
+                        st.write(f"**Type:** {row['type']}")
+                    with col4:
+                        st.write(f"**Lines:** {row['lineno']}-{row['endline']}")
+
+                    st.write(f"**File:** `{row['filepath']}`")
+                    full_name = (
+                        f"{row['classname']}.{row['name']}"
+                        if row["type"] == "method"
+                        else row["name"]
+                    )
+                    st.write(f"**Full Name:** `{full_name}`")
+
+                    # Recommendation
+                    if row["complexity"] >= complexity_threshold + 5:
+                        st.error("🔴 **CRITICAL:** This needs immediate refactoring")
+                    elif row["complexity"] >= complexity_threshold:
+                        st.warning(
+                            "🟠 **HIGH:** Consider breaking this into smaller functions"
+                        )
+
+                    if row["rank"] in ["D", "E", "F"]:
+                        st.warning(
+                            f"**Grade {row['rank']}:** Code quality is poor, refactoring recommended"
+                        )
+        else:
+            st.success("✅ No risky items found! Your code looks good.")
+
+    # ===== TAB 4: DETAILED VIEW =====
+    with tab4:
+        st.subheader("Detailed Item Analysis")
+
+        # Select item to analyze
+        df_display = df.copy()
+        df_display["display_name"] = df_display.apply(
+            lambda x: f"{x['name']} ({x['type']}) - {x['filepath'].split('/')[-1]}",
+            axis=1,
+        )
+
+        selected_item = st.selectbox(
+            "Select an item to analyze",
+            options=df_display.index,
+            format_func=lambda x: df_display.loc[x, "display_name"],
+        )
+
+        if selected_item is not None:
+            item = df.iloc[selected_item]
+
+            # Header with grade badge
+            col1, col2 = st.columns([3, 1])
+            with col1:
+                st.title(item["name"])
+            with col2:
+                grade_html = display_grade_badge(item["rank"])
+                st.markdown(grade_html, unsafe_allow_html=True)
+
+            st.divider()
+
+            # Detailed metrics
+            col1, col2, col3, col4, col5 = st.columns(5)
+            with col1:
+                st.metric("Complexity", item["complexity"])
+            with col2:
+                st.metric("Type", item["type"])
+            with col3:
+                st.metric("Start Line", int(item["lineno"]))
+            with col4:
+                st.metric("End Line", int(item["endline"]))
+            with col5:
+                st.metric("Lines of Code", int(item["endline"] - item["lineno"] + 1))
+
+            st.divider()
+
+            # File and location info
+            col1, col2 = st.columns(2)
+            with col1:
+                st.write("**File Path:**")
+                st.code(item["filepath"], language="text")
+            with col2:
+                st.write("**Location:**")
+                st.code(
+                    f"Line {int(item['lineno'])} to {int(item['endline'])}, Column {int(item['col_offset'])}",
+                    language="text",
+                )
+
+            if item["classname"]:
+                st.write("**Class Name:**")
+                st.code(item["classname"], language="text")
+
+            st.divider()
+
+            # Recommendations
+            st.subheader("💡 Recommendations")
+
+            complexity = int(item["complexity"])
+            if complexity <= 3:
+                st.success(
+                    "✅ **Simple:** This code is easy to understand and maintain."
+                )
+            elif complexity <= 7:
+                st.info(
+                    "ℹ️ **Moderate:** Code is reasonably complex. Consider breaking into smaller functions if it exceeds 7."
+                )
+            elif complexity <= 10:
+                st.warning(
+                    "⚠️ **Complex:** This code is complex and may be difficult to maintain. Consider refactoring."
+                )
+            else:
+                st.error(
+                    "🔴 **Very Complex:** This code needs immediate refactoring. Break it into smaller, testable units."
+                )
+
+            if item["rank"] in ["D", "E", "F"]:
+                st.error(
+                    f"📉 **Grade {item['rank']}:** Code quality needs improvement."
+                )
+
+else:
+    # Landing page
+    st.title("📊 Radon Complexity Analyzer")
+    st.markdown(
+        """
+    Welcome to the Radon Cyclomatic Complexity Analyzer!
+
+    This tool helps you analyze and visualize Python code complexity reports from the **radon** library.
+
+    ### Features:
+    - 📈 **Overview:** See complexity distribution across your codebase
+    - 🔍 **Analysis:** Filter, sort, and search for specific functions/classes
+    - ⚠️ **Warnings:** Identify items that need immediate attention
+    - 📋 **Details:** Get detailed analysis and recommendations for each item
+
+    ### How to use:
+    1. Generate a radon complexity report as JSON:
+       ```bash
+       radon cc your_project/ -j > report.json
+       ```
+    2. Upload the JSON file using the sidebar
+    3. Explore and analyze your code complexity!
+    """
+    )
+
+    # Create sample data for demonstration
+    st.divider()
+    st.subheader("Or try with sample data:")
+
+    if st.button("Load Sample Report"):
+        sample_report = {
+            "example/settings.py": [
+                {
+                    "type": "class",
+                    "rank": "A",
+                    "lineno": 7,
+                    "complexity": 1,
+                    "endline": 8,
+                    "name": "DBSettings",
+                    "col_offset": 0,
+                    "methods": [],
+                },
+                {
+                    "type": "class",
+                    "rank": "B",
+                    "lineno": 11,
+                    "complexity": 5,
+                    "endline": 13,
+                    "name": "ComplexSettings",
+                    "col_offset": 0,
+                    "methods": [
+                        {
+                            "type": "method",
+                            "rank": "C",
+                            "lineno": 12,
+                            "classname": "ComplexSettings",
+                            "complexity": 8,
+                            "endline": 13,
+                            "name": "validate",
+                            "col_offset": 4,
+                            "closures": [],
+                        }
+                    ],
+                },
+            ],
+            "example/base.py": [
+                {
+                    "type": "function",
+                    "rank": "F",
+                    "lineno": 1,
+                    "complexity": 15,
+                    "endline": 50,
+                    "name": "complex_function",
+                    "col_offset": 0,
+                }
+            ],
+        }
+
+        st.session_state.report_data = sample_report
+        st.session_state.df = flatten_report(sample_report)
+        st.success("✅ Sample data loaded! Refresh the page to see the analysis.")
+        st.rerun()