Create app.py

app.py

@@ -0,0 +1,506 @@
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+import gradio as gr
+import io
+import base64
+import tempfile
+import os
+from datetime import datetime
+
+# --- Matplotlib Plot to Base64 ---
+def fig_to_base64(fig):
+    """Converts a Matplotlib figure to a base64 encoded PNG string."""
+    buf = io.BytesIO()
+    fig.savefig(buf, format='png', bbox_inches='tight')
+    plt.close(fig) # Close the figure to free memory
+    buf.seek(0)
+    img_str = base64.b64encode(buf.read()).decode('utf-8')
+    return f"data:image/png;base64,{img_str}"
+
+# --- EDA Helper Functions (Adapted from Colab) ---
+
+def get_initial_inspection_html(df):
+    """Generates HTML for initial data inspection."""
+    html = "<h2>1. Initial Data Inspection</h2>"
+    # Head
+    html += "<h3>(a) First 5 Rows (Head):</h3>"
+    html += df.head().to_html(classes='table table-striped', border=1)
+    # Tail
+    html += "<h3>(b) Last 5 Rows (Tail):</h3>"
+    html += df.tail().to_html(classes='table table-striped', border=1)
+    # Shape
+    html += "<h3>(c) Dataset Shape:</h3>"
+    html += f"<p>Number of Rows: {df.shape[0]}</p>"
+    html += f"<p>Number of Columns: {df.shape[1]}</p>"
+    # Info
+    html += "<h3>(d) Data Types and Non-Null Counts (Info):</h3>"
+    buffer = io.StringIO()
+    df.info(buf=buffer)
+    info_str = buffer.getvalue()
+    html += f"<pre>{info_str}</pre>"
+    # Column Names
+    html += "<h3>(e) Column Names:</h3>"
+    html += f"<p><code>{list(df.columns)}</code></p>"
+    return html
+
+def get_descriptive_stats_html(df):
+    """Generates HTML for descriptive statistics."""
+    html = "<h2>2. Descriptive Statistics</h2>"
+    # Numerical
+    html += "<h3>(a) Numerical Columns Statistics:</h3>"
+    try:
+        num_stats = df.describe(include=np.number)
+        if not num_stats.empty:
+             html += num_stats.to_html(classes='table table-striped', border=1, float_format='%.2f')
+        else:
+            html += "<p>No numerical columns found.</p>"
+    except Exception as e:
+        html += f"<p>Error generating numerical stats: {e}</p>"
+
+    # Categorical
+    html += "<h3>(b) Categorical/Object Columns Statistics:</h3>"
+    try:
+        cat_stats = df.describe(include=['object', 'category'])
+        if not cat_stats.empty:
+            html += cat_stats.to_html(classes='table table-striped', border=1)
+        else:
+            html += "<p>No categorical/object columns found.</p>"
+    except Exception as e:
+        html += f"<p>Error generating categorical stats: {e}</p>"
+    return html
+
+def identify_column_types_html(df):
+    """Generates HTML listing identified column types."""
+    html = "<h2>3. Identifying Column Types</h2>"
+    numerical_cols = df.select_dtypes(include=np.number).columns.tolist()
+    categorical_cols = df.select_dtypes(include=['object', 'category']).columns.tolist()
+    datetime_cols = df.select_dtypes(include=['datetime', 'datetime64']).columns.tolist()
+    boolean_cols = df.select_dtypes(include=['bool']).columns.tolist()
+    other_cols = df.columns.difference(numerical_cols + categorical_cols + datetime_cols + boolean_cols).tolist()
+
+    html += f"<p><b>Numerical Columns ({len(numerical_cols)}):</b> <code>{numerical_cols}</code></p>"
+    html += f"<p><b>Categorical Columns ({len(categorical_cols)}):</b> <code>{categorical_cols}</code></p>"
+    html += f"<p><b>DateTime Columns ({len(datetime_cols)}):</b> <code>{datetime_cols}</code></p>"
+    html += f"<p><b>Boolean Columns ({len(boolean_cols)}):</b> <code>{boolean_cols}</code></p>"
+    if other_cols:
+        html += f"<p><b>Other/Unclassified Columns ({len(other_cols)}):</b> <code>{other_cols}</code></p>"
+
+    # Store for later use (return them)
+    return html, numerical_cols, categorical_cols # Return lists as well
+
+def analyze_missing_values_html(df):
+    """Generates HTML for missing value analysis."""
+    html = "<h2>4. Missing Value Analysis</h2>"
+    missing_values = df.isnull().sum()
+    missing_percent = (missing_values / len(df)) * 100
+    missing_table = pd.concat([missing_values, missing_percent], axis=1, keys=['Missing Count', 'Missing (%)'])
+    missing_table = missing_table[missing_table['Missing Count'] > 0].sort_values('Missing (%)', ascending=False)
+
+    if not missing_table.empty:
+        html += "<h3>(a) Columns with Missing Values:</h3>"
+        html += missing_table.to_html(classes='table table-striped', border=1, float_format='%.2f')
+
+        # Heatmap
+        html += "<h3>(b) Missing Values Heatmap:</h3>"
+        try:
+            fig, ax = plt.subplots(figsize=(15, 7))
+            sns.heatmap(df.isnull(), cbar=False, cmap='viridis', ax=ax)
+            ax.set_title('Heatmap of Missing Values per Column')
+            img_str = fig_to_base64(fig)
+            html += f'<img src="{img_str}" alt="Missing Values Heatmap"><br>'
+            html += "<p><i>Consider strategies like imputation or deletion based on the results.</i></p>"
+        except Exception as e:
+             html += f"<p>Could not generate missing value heatmap. Error: {e}</p>"
+    else:
+        html += "<p>No missing values found in the dataset. Great!</p>"
+    return html
+
+def analyze_univariate_numerical_html(df, numerical_cols):
+    """Generates HTML for univariate analysis of numerical columns."""
+    html = "<h2>5. Univariate Analysis (Numerical Columns)</h2>"
+    html += "<p><i>Analyzing distributions of individual numerical features using Histograms and Box Plots.</i></p>"
+    if not numerical_cols:
+        html += "<p>No numerical columns found to analyze.</p>"
+        return html
+
+    for col in numerical_cols:
+        html += f"<h3>Analyzing: '{col}'</h3>"
+        try:
+            # Create subplots
+            fig, axes = plt.subplots(1, 2, figsize=(16, 5)) # 1 row, 2 columns
+
+            # Plot Histogram
+            sns.histplot(df[col], kde=True, bins=30, ax=axes[0])
+            axes[0].set_title(f'Histogram of {col}')
+            axes[0].set_xlabel(col)
+            axes[0].set_ylabel('Frequency')
+
+            # Plot Box Plot
+            sns.boxplot(y=df[col], ax=axes[1])
+            axes[1].set_title(f'Box Plot of {col}')
+            axes[1].set_ylabel(col)
+
+            plt.tight_layout()
+            img_str = fig_to_base64(fig)
+            html += f'<img src="{img_str}" alt="Plots for {col}"><br>'
+
+            # Skewness
+            skewness = df[col].skew()
+            html += f"<p><b>Skewness:</b> {skewness:.2f} "
+            if skewness > 0.5: html += "(Moderately Right-Skewed)"
+            elif skewness < -0.5: html += "(Moderately Left-Skewed)"
+            else: html += "(Approximately Symmetric)"
+            html += "</p><hr>"
+
+        except Exception as e:
+            html += f"<p>Could not generate plots for {col}. Error: {e}</p><hr>"
+
+    return html
+
+def analyze_univariate_categorical_html(df, categorical_cols):
+    """Generates HTML for univariate analysis of categorical columns."""
+    html = "<h2>6. Univariate Analysis (Categorical Columns)</h2>"
+    html += "<p><i>Analyzing frequency distributions of individual categorical features using Count Plots.</i></p>"
+    if not categorical_cols:
+        html += "<p>No categorical/object columns found to analyze.</p>"
+        return html
+
+    plot_threshold = 50 # Max unique values for plotting
+
+    for col in categorical_cols:
+        html += f"<h3>Analyzing: '{col}'</h3>"
+        try:
+            unique_count = df[col].nunique()
+            html += f"<p><b>Number of Unique Values:</b> {unique_count}</p>"
+
+            if unique_count == 0:
+                html += "<p><i>Column has no values.</i></p><hr>"
+                continue
+            elif unique_count > plot_threshold:
+                html += f"<p><i>Skipping plot as unique value count ({unique_count}) exceeds threshold ({plot_threshold}). Showing Top 15 value counts instead.</i></p>"
+                top_15_counts = df[col].value_counts().head(15)
+                html += "<pre>" + top_15_counts.to_string() + "</pre><hr>"
+            else:
+                # Plot Count Plot
+                fig, ax = plt.subplots(figsize=(10, max(5, unique_count * 0.3))) # Adjust height
+                plot_order = df[col].value_counts().index
+                sns.countplot(y=df[col], order=plot_order, palette='viridis', ax=ax)
+                ax.set_title(f'Frequency Count of {col}')
+                ax.set_xlabel('Count')
+                ax.set_ylabel(col)
+                plt.tight_layout()
+                img_str = fig_to_base64(fig)
+                html += f'<img src="{img_str}" alt="Count Plot for {col}"><hr>'
+
+        except Exception as e:
+            html += f"<p>Could not generate plot/counts for {col}. Error: {e}</p><hr>"
+
+    return html
+
+def analyze_bivariate_numerical_html(df, numerical_cols):
+    """Generates HTML for bivariate analysis of numerical columns."""
+    html = "<h2>7. Bivariate Analysis (Numerical vs. Numerical)</h2>"
+    html += "<p><i>Analyzing relationships between pairs of numerical features using Correlation Matrix and Pair Plots.</i></p>"
+
+    if len(numerical_cols) < 2:
+        html += "<p>Need at least two numerical columns for this analysis.</p>"
+        return html
+
+    # Correlation Heatmap
+    html += "<h3>(a) Correlation Matrix Heatmap:</h3>"
+    try:
+        correlation_matrix = df[numerical_cols].corr()
+        fig, ax = plt.subplots(figsize=(12, 10))
+        sns.heatmap(correlation_matrix, annot=True, cmap='coolwarm', fmt=".2f", linewidths=.5, ax=ax)
+        ax.set_title('Correlation Matrix of Numerical Features')
+        img_str = fig_to_base64(fig)
+        html += f'<img src="{img_str}" alt="Correlation Matrix"><br>'
+        html += "<p><i>Interpretation: Values close to +1 indicate strong positive linear correlation, close to -1 indicate strong negative linear correlation, close to 0 indicate weak or no linear correlation.</i></p>"
+    except Exception as e:
+        html += f"<p>Could not generate correlation heatmap. Error: {e}</p>"
+
+    # Pair Plot
+    pairplot_threshold = 7 # Limit features for pairplot
+    html += f"<h3>(b) Pair Plot (Threshold: {pairplot_threshold} features):</h3>"
+    if len(numerical_cols) <= pairplot_threshold:
+        html += f"<p><i>Generating Pair Plot for {len(numerical_cols)} numerical features... (May take a moment)</i></p>"
+        try:
+            pair_plot_fig = sns.pairplot(df[numerical_cols], diag_kind='kde')
+            pair_plot_fig.fig.suptitle('Pair Plot of Numerical Features', y=1.02) # Adjust title position
+            # Convert the PairGrid object's figure to base64
+            img_str = fig_to_base64(pair_plot_fig.fig)
+            html += f'<img src="{img_str}" alt="Pair Plot"><br>'
+        except Exception as e:
+            html += f"<p>Could not generate pair plot. Error: {e}</p>"
+            html += "<p><i>Pairplots can sometimes fail with certain data types or distributions, or if memory is limited.</i></p>"
+    else:
+        html += f"<p><i>Skipping Pair Plot because the number of numerical features ({len(numerical_cols)}) exceeds the threshold ({pairplot_threshold}).</i></p>"
+
+    return html
+
+def analyze_bivariate_num_cat_html(df, numerical_cols, categorical_cols):
+    """Generates HTML for bivariate analysis of numerical vs. categorical columns."""
+    html = "<h2>8. Bivariate Analysis (Numerical vs. Categorical)</h2>"
+    html += "<p><i>Analyzing distributions of numerical features across different categories using Box Plots.</i></p>"
+
+    if not numerical_cols or not categorical_cols:
+        html += "<p>Need both numerical and categorical columns for this analysis.</p>"
+        return html
+
+    cat_nunique_threshold = 20
+    cats_to_analyze = [col for col in categorical_cols if df[col].nunique() <= cat_nunique_threshold]
+
+    if not cats_to_analyze:
+        html += f"<p>No categorical columns with a reasonable number of unique values (<= {cat_nunique_threshold}) found for plotting against numerical features.</p>"
+        return html
+
+    html += f"<p><i>Analyzing numerical columns against these categorical columns (max {cat_nunique_threshold} unique values): <code>{cats_to_analyze}</code></i></p>"
+
+    for num_col in numerical_cols:
+        for cat_col in cats_to_analyze:
+            html += f"<h3>Analyzing: '{num_col}' vs '{cat_col}'</h3>"
+            try:
+                 # Check if category column has data
+                if df[cat_col].isnull().all() or df[cat_col].nunique() == 0:
+                    html += f"<p><i>Skipping plot: Categorical column '{cat_col}' has no valid data or only one unique value after dropping NaNs.</i></p><hr>"
+                    continue
+
+                fig, ax = plt.subplots(figsize=(12, 6))
+                sns.boxplot(x=df[cat_col], y=df[num_col], palette='viridis', ax=ax, order=sorted(df[cat_col].dropna().unique())) # Added order and dropna
+                ax.set_title(f'Box Plot of {num_col} by {cat_col}')
+                ax.set_xlabel(cat_col)
+                ax.set_ylabel(num_col)
+
+                # Rotate x-axis labels if they are long or numerous
+                if df[cat_col].nunique() > 5:
+                    plt.xticks(rotation=45, ha='right')
+
+                plt.tight_layout()
+                img_str = fig_to_base64(fig)
+                html += f'<img src="{img_str}" alt="Box plot of {num_col} by {cat_col}"><hr>'
+
+            except Exception as e:
+                html += f"<p>Could not generate box plot for '{num_col}' vs '{cat_col}'. Error: {e}</p><hr>"
+
+    return html
+
+def get_analysis_summary_html(df, missing_table_html):
+    """Generates HTML for the summary section."""
+    html = "<h2>9. Analysis Summary & Next Steps</h2>"
+    html += "<p>This automated analysis provided a first look at the dataset's structure, content, distributions, and basic relationships.</p>"
+    html += "<h3>Key Observations (Auto-Generated Summary):</h3>"
+    html += f"<ul><li>The dataset has <b>{df.shape[0]}</b> rows and <b>{df.shape[1]}</b> columns.</li>"
+    # Add more sophisticated summary points based on analysis if desired
+    if "Columns with Missing Values" in missing_table_html:
+         html += "<li>Missing values were detected (see Section 4 for details).</li>"
+    else:
+         html += "<li>No missing values were found.</li>"
+    html += "<li>Review the plots in Sections 5-8 for insights into distributions and relationships.</li>"
+    html += "<li><i>(Note: This is a basic summary. Customize with specific findings based on the generated report.)</i></li></ul>"
+
+    html += "<h3>Potential Next Steps:</h3>"
+    html += "<ol>"
+    html += "<li><b>Data Cleaning:</b> Address missing values (imputation/deletion), correct data types if needed, handle outliers (if appropriate).</li>"
+    html += "<li><b>Feature Engineering:</b> Create new features from existing ones (e.g., extracting date parts, combining categories).</li>"
+    html += "<li><b>Deeper Analysis:</b> Explore relationships further (statistical tests, different plots, multivariate analysis).</li>"
+    html += "<li><b>Domain-Specific Analysis:</b> Apply subject matter expertise for targeted questions.</li>"
+    html += "<li><b>Modeling:</b> Prepare data and build machine learning models if applicable.</li>"
+    html += "</ol>"
+    return html
+
+def get_bonus_guide_html():
+    """Generates HTML for the bonus guide."""
+    html = """
+    <h2>Bonus: How to Understand & Read Any Dataset</h2>
+    <p>Approaching a new dataset systematically:</p>
+    <ol>
+        <li><strong>Understand the Context:</strong> Source, purpose, data dictionary, timeframe.</li>
+        <li><strong>Load and Get a First Look:</strong> Use tools like pandas, check dimensions (`.shape`), peek at data (`.head()`, `.tail()`).</li>
+        <li><strong>Examine Metadata and Structure:</strong> Check column names (`.columns`), data types (`.info()`), memory usage. Correct types if necessary.</li>
+        <li><strong>Summarize the Data:</strong> Use `.describe()` for numerical (mean, median, std, min/max, quartiles) and categorical (unique count, top value, frequency) summaries. Check `.value_counts()` for specific categories.</li>
+        <li><strong>Handle Missing Data:</strong> Identify (`.isnull().sum()`) and quantify missing values. Decide on a strategy (deletion, imputation).</li>
+        <li><strong>Visualize (EDA):</strong>
+            <ul>
+                <li><em>Univariate:</em> Histograms, density plots, box plots (numerical); Count plots (categorical).</li>
+                <li><em>Bivariate:</em> Scatter plots, correlation matrix/heatmap (numerical vs. numerical); Box plots, violin plots (numerical vs. categorical); Crosstabs, stacked bars (categorical vs. categorical).</li>
+                <li><em>Multivariate:</em> Pair plots, faceting.</li>
+            </ul>
+        </li>
+        <li><strong>Ask Questions:</strong> Formulate specific questions based on context and initial findings.</li>
+        <li><strong>Iterate and Document:</strong> Data understanding is iterative. Document findings and decisions.</li>
+    </ol>
+    """
+    return html
+
+
+# --- Main Gradio Function ---
+
+def generate_eda_report(uploaded_file):
+    """
+    Main function called by Gradio. Takes an uploaded file, performs EDA,
+    and returns the path to a generated HTML report file.
+    """
+    start_time = datetime.now()
+    if uploaded_file is None:
+        raise gr.Error("No file uploaded! Please upload a CSV file.")
+
+    try:
+        # Set visualization styles globally for the run
+        sns.set(style="whitegrid")
+        plt.rcParams['figure.figsize'] = (12, 6)
+        pd.set_option('display.max_columns', 50)
+        pd.set_option('display.float_format', lambda x: '%.2f' % x)
+
+        # Check file size (example: 100MB limit)
+        file_size_mb = os.path.getsize(uploaded_file.name) / (1024 * 1024)
+        if file_size_mb > 100:
+            raise gr.Error(f"File size ({file_size_mb:.2f} MB) exceeds the 100 MB limit.")
+
+        # Read the CSV file
+        # Use the temporary path provided by Gradio's File component
+        df = pd.read_csv(uploaded_file.name)
+
+        # Start building the HTML report
+        html_content = """
+        <!DOCTYPE html>
+        <html lang="en">
+        <head>
+            <meta charset="UTF-8">
+            <meta name="viewport" content="width=device-width, initial-scale=1.0">
+            <title>Automated EDA Report</title>
+            <style>
+                body { font-family: sans-serif; margin: 20px; }
+                h1, h2, h3 { color: #333; }
+                h1 { text-align: center; border-bottom: 2px solid #eee; padding-bottom: 10px; }
+                h2 { border-bottom: 1px solid #eee; padding-bottom: 5px; margin-top: 30px; }
+                h3 { margin-top: 20px; color: #555; }
+                table { border-collapse: collapse; width: auto; margin-top: 15px; margin-bottom: 15px; }
+                th, td { border: 1px solid #ddd; padding: 8px; text-align: left; }
+                th { background-color: #f2f2f2; }
+                tr:nth-child(even) { background-color: #f9f9f9; }
+                pre { background-color: #f5f5f5; padding: 10px; border: 1px solid #ccc; overflow-x: auto; }
+                code { background-color: #eee; padding: 2px 4px; border-radius: 3px; }
+                img { max-width: 100%; height: auto; display: block; margin: 15px auto; border: 1px solid #ddd; }
+                hr { border: 0; height: 1px; background: #ddd; margin: 30px 0; }
+            </style>
+        </head>
+        <body>
+            <h1>📊 Automated Data Explorer & Visualizer Report 📊</h1>
+        """
+        report_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        html_content += f"<p style='text-align:center;'><i>Report generated on: {report_time}</i></p>"
+        html_content += f"<p style='text-align:center;'><i>Input file: {os.path.basename(uploaded_file.name)}</i></p>"
+
+
+        # --- Run EDA Steps ---
+        # 1. Initial Inspection
+        html_content += get_initial_inspection_html(df)
+        html_content += "<hr>"
+
+        # 2. Descriptive Statistics
+        html_content += get_descriptive_stats_html(df)
+        html_content += "<hr>"
+
+        # 3. Identify Column Types
+        col_types_html, num_cols, cat_cols = identify_column_types_html(df)
+        html_content += col_types_html
+        html_content += "<hr>"
+
+        # 4. Missing Values
+        missing_html = analyze_missing_values_html(df)
+        html_content += missing_html
+        html_content += "<hr>"
+
+        # 5. Univariate Numerical
+        html_content += analyze_univariate_numerical_html(df, num_cols)
+        html_content += "<hr>"
+
+        # 6. Univariate Categorical
+        html_content += analyze_univariate_categorical_html(df, cat_cols)
+        html_content += "<hr>"
+
+        # 7. Bivariate Numerical vs Numerical
+        html_content += analyze_bivariate_numerical_html(df, num_cols)
+        html_content += "<hr>"
+
+        # 8. Bivariate Numerical vs Categorical
+        html_content += analyze_bivariate_num_cat_html(df, num_cols, cat_cols)
+        html_content += "<hr>"
+
+        # 9. Summary
+        html_content += get_analysis_summary_html(df, missing_html) # Pass missing_html to check if missing values were found
+        html_content += "<hr>"
+
+        # 10. Bonus Guide
+        html_content += get_bonus_guide_html()
+
+        # --- Finalize HTML ---
+        html_content += f"<p style='text-align:center; margin-top: 30px;'><i>--- End of Report ---</i></p>"
+        end_time = datetime.now()
+        duration = end_time - start_time
+        html_content += f"<p style='text-align:center; font-size: small; color: grey;'><i>Analysis completed in {duration.total_seconds():.2f} seconds.</i></p>"
+        html_content += """
+            </body>
+            </html>
+            """
+
+        # Save HTML content to a temporary file
+        # Use tempfile for better cross-platform compatibility and automatic cleanup
+        with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix=".html", encoding='utf-8') as temp_file:
+            temp_file.write(html_content)
+            report_path = temp_file.name # Get the path of the temp file
+
+        # Return the path to the generated HTML file for Gradio output
+        return report_path
+
+    except pd.errors.ParserError:
+        raise gr.Error("Error parsing CSV file. Please ensure it is a valid CSV format and delimiter is correctly inferred (usually comma).")
+    except FileNotFoundError:
+         raise gr.Error("Uploaded file not found. Please try uploading again.")
+    except ValueError as ve: # Catch specific value errors like Colab's upload error
+         raise gr.Error(f"Value Error: {ve}")
+    except Exception as e:
+        # Generic error catch - useful for debugging
+        import traceback
+        tb_str = traceback.format_exc()
+        print(f"An unexpected error occurred: {e}\n{tb_str}") # Log to console
+        raise gr.Error(f"An unexpected error occurred during analysis: {e}. Check console logs if running locally.")
+
+
+# --- Gradio Interface Setup ---
+
+description = """
+**Effortless Dataset Insights 📊**
+
+Upload your CSV dataset (max 100MB) and get an automated Exploratory Data Analysis (EDA) report.
+The report includes:
+1. Basic Info (Shape, Data Types, Head/Tail)
+2. Descriptive Statistics
+3. Missing Value Analysis & Heatmap
+4. Univariate Analysis (Histograms, Box Plots, Count Plots)
+5. Bivariate Analysis (Correlation Heatmap, Pair Plot [small datasets], Box Plots by Category)
+6. Summary & Next Steps Guide
+
+The output will be an HTML file that you can download and view in your browser.
+"""
+
+iface = gr.Interface(
+    fn=generate_eda_report,
+    inputs=gr.File(label="Upload CSV Dataset", file_types=[".csv"]),
+    outputs=gr.File(label="Download EDA Report (.html)"),
+    title="Effortless Dataset Insights",
+    description=description,
+    allow_flagging="never",
+    examples=[
+        # You can add paths to example CSV files here if you host them somewhere
+        # e.g., ["./examples/sample_data.csv"]
+        # Ensure these files exist if you uncomment this
+    ],
+     theme=gr.themes.Soft() # Optional: Apply a theme
+)
+
+# --- Launch the App ---
+if __name__ == "__main__":
+    iface.launch()