Delete app.py

app.py

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