sample report changes

app.py

@@ -1,680 +0,0 @@
-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()

src/streamlit_app.py

@@ -626,55 +626,69 @@ else:
     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()
+        sample_file_path = Path(__file__).parent / "sample_report.json"
+
+        try:
+            with open(sample_file_path, "r") as f:
+                sample_report = json.load(f)
+
+            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()
+        except FileNotFoundError:
+            st.error("❌ Sample report file not found. Please upload your own report.")
+        except Exception as e:
+            st.error(f"❌ Error loading sample data: {str(e)}")
+        # 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()