intelaish 0.1.0__tar.gz

intelaish-0.1.0/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: intelaish
+Version: 0.1.0
+Summary: Next-generation automated EDA, cleaning, and AI insights.
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: pandas>=2.0.0
+Requires-Dist: numpy>=1.24.0
+Requires-Dist: plotly>=5.14.0
+Requires-Dist: scikit-learn>=1.2.0
+Requires-Dist: google-genai>=0.2.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: statsmodels>=0.14.0
+Requires-Dist: shap>=0.42.0
+Requires-Dist: matplotlib>=3.7.0

intelaish-0.1.0/intelaish/__init__.py

@@ -0,0 +1,9 @@
+from .ingestion import smart_read
+from .cleaning import smart_clean
+from .visuals import smart_viz, advanced_viz
+from .insights import SmartInsights
+from .models import problem_card
+from .explain import explain_model
+from .sql_engine import SQLBridge
+
+__version__ = "0.1.0"

intelaish-0.1.0/intelaish/cleaning.py

@@ -0,0 +1,69 @@
+import pandas as pd
+import numpy as np
+from rich.console import Console
+from rich.table import Table
+
+console = Console()
+
+
+def smart_clean(df: pd.DataFrame, target: str = None, outlier_strategy: str = "iqr") -> pd.DataFrame:
+    """
+    Automatically detects and fixes missing values and outliers in a DataFrame.
+    Skips outlier detection for the specified target variable to prevent data destruction.
+    """
+    cleaned_df = df.copy()
+    console.print(
+        "\n[bold blue]🧹 Starting Intelligent Data Cleaning Engine (Robust IQR)...[/bold blue]")
+    actions = []
+
+    for col in cleaned_df.columns:
+        # 1. Handle Missing Values (We still want to fill missing target values if they exist)
+        missing_count = cleaned_df[col].isnull().sum()
+        if missing_count > 0:
+            if cleaned_df[col].dtype in ['int64', 'float64']:
+                fill_val = cleaned_df[col].median()
+                cleaned_df[col] = cleaned_df[col].fillna(fill_val)
+                actions.append({"Column": col, "Issue": "Missing Values",
+                               "Action": f"Filled {missing_count} rows with Median ({fill_val})"})
+            else:
+                fill_val = cleaned_df[col].mode()[0]
+                cleaned_df[col] = cleaned_df[col].fillna(fill_val)
+                actions.append({"Column": col, "Issue": "Missing Values",
+                               "Action": f"Filled {missing_count} rows with Mode ('{fill_val}')"})
+
+        # 2. Handle Outliers using IQR (SKIP if it is the target variable!)
+        if cleaned_df[col].dtype in ['int64', 'float64'] and col != target:
+            Q1 = cleaned_df[col].quantile(0.25)
+            Q3 = cleaned_df[col].quantile(0.75)
+            IQR = Q3 - Q1
+
+            # Avoid divide by zero/zero variance issues
+            if IQR > 0:
+                lower_bound = Q1 - 1.5 * IQR
+                upper_bound = Q3 + 1.5 * IQR
+
+                outliers = (cleaned_df[col] < lower_bound) | (
+                    cleaned_df[col] > upper_bound)
+                outlier_count = outliers.sum()
+
+                if outlier_count > 0:
+                    cleaned_df[col] = np.clip(
+                        cleaned_df[col], lower_bound, upper_bound)
+                    actions.append({"Column": col, "Issue": "Outliers Detected",
+                                   "Action": f"Capped {outlier_count} values using IQR Bounds"})
+
+    # Print summary layout
+    if actions:
+        table = Table(title="✨ intelguruai Cleaning Summary",
+                      show_header=True, header_style="bold magenta")
+        table.add_column("Column Name", style="cyan")
+        table.add_column("Issue Found", style="yellow")
+        table.add_column("Action Taken", style="green")
+
+        for act in actions:
+            table.add_row(act["Column"], act["Issue"], act["Action"])
+        console.print(table)
+    else:
+        console.print("[bold green]🎉 Dataset is already clean![/bold green]")
+
+    return cleaned_df

intelaish-0.1.0/intelaish/explain.py

@@ -0,0 +1,66 @@
+import pandas as pd
+import shap
+import matplotlib.pyplot as plt
+from sklearn.ensemble import RandomForestClassifier, RandomForestRegressor
+from sklearn.preprocessing import LabelEncoder
+from rich.console import Console
+
+console = Console()
+
+
+def explain_model(df: pd.DataFrame, target: str, is_classification: bool = True):
+    """
+    Trains a baseline model and uses SHAP values to explain feature importance,
+    acting as a foundation for bias detection and model interpretability.
+    """
+    console.print(
+        f"\n[bold magenta]🔍 Launching Interpretability & Bias Detection Engine...[/bold magenta]")
+
+    # 1. Prepare data (Drop NaNs for the background model)
+    df_clean = df.dropna().copy()
+    if target not in df_clean.columns:
+        console.print(f"[bold red]❌ Target '{target}' not found.[/bold red]")
+        return
+
+    X = df_clean.drop(columns=[target])
+    y = df_clean[target]
+
+    # 2. Encode categorical variables for the model
+    for col in X.select_dtypes(include=['object', 'category']).columns:
+        X[col] = LabelEncoder().fit_transform(X[col].astype(str))
+
+    if y.dtype == 'object' or str(y.dtype) == 'category':
+        y = LabelEncoder().fit_transform(y.astype(str))
+
+    # 3. Train the baseline model
+    model = RandomForestClassifier(
+        random_state=42) if is_classification else RandomForestRegressor(random_state=42)
+    model.fit(X, y)
+
+    # 4. Calculate SHAP values for interpretability
+    console.print(
+        "[bold cyan]⚙️ Calculating SHAP values for feature importance...[/bold cyan]")
+    explainer = shap.TreeExplainer(model)
+
+    # Use a sample if the dataset is massive to save time
+    X_sample = X.sample(min(len(X), 500)) if len(X) > 500 else X
+    shap_values = explainer.shap_values(X_sample)
+
+    # 5. Render the plot
+    console.print("[bold green]✅ SHAP Summary Plot Generated![/bold green]")
+
+    if is_classification and isinstance(shap_values, list):
+        shap.summary_plot(shap_values[1], X_sample, show=False)
+    else:
+        shap.summary_plot(shap_values, X_sample, show=False)
+
+    plt.title(f"Feature Importance & Bias Check for '{target}'")
+    plt.tight_layout()
+
+    # Save the file instead of blocking the terminal
+    file_name = f"shap_summary_{target}.png"
+    plt.savefig(file_name, bbox_inches='tight', dpi=300, facecolor='white')
+    plt.close()
+
+    console.print(
+        f"[bold green]✅ SHAP Summary Plot saved to your folder as '{file_name}'![/bold green]")

intelaish-0.1.0/intelaish/ingestion.py

@@ -0,0 +1,33 @@
+import pandas as pd
+from rich.console import Console
+from rich.panel import Panel
+
+console = Console()
+
+
+def smart_read(file_path: str) -> pd.DataFrame:
+    """
+    Reads a CSV file, prints a beautiful summary to the console, 
+    and returns a pandas DataFrame.
+    """
+    console.print(
+        f"[bold green]⏳ Loading dataset from:[/bold green] {file_path}")
+
+    try:
+        # Load the data
+        df = pd.read_csv(file_path)
+
+        # Print a beautiful confirmation panel
+        console.print(Panel(
+            f"[bold green]✅ Successfully Loaded![/bold green]\n\n"
+            f"📊 [bold]Rows:[/bold] {df.shape[0]} | [bold]Columns:[/bold] {df.shape[1]}\n"
+            f"💾 [bold]Memory Usage:[/bold] {df.memory_usage(deep=True).sum() / 1024**2:.2f} MB",
+            title="intelguruai Ingestion Engine",
+            expand=False
+        ))
+
+        return df
+
+    except Exception as e:
+        console.print(f"[bold red]❌ Error loading file:[/bold red] {str(e)}")
+        raise e

intelaish-0.1.0/intelaish/insights.py

@@ -0,0 +1,98 @@
+import pandas as pd
+import json
+from google import genai
+from rich.console import Console
+from rich.panel import Panel
+
+console = Console()
+
+
+class SmartInsights:
+    def __init__(self, api_key: str = None):
+        """
+        Initializes the AI insight engine. If an API key is provided, 
+        it prepares the modern Gemini client. Otherwise, it uses local statistical heuristics.
+        """
+        self.api_key = api_key
+        if api_key:
+            try:
+                # Upgraded Initialization: Using the new unified SDK client
+                self.client = genai.Client(api_key=api_key)
+                self.ai_enabled = True
+            except Exception as e:
+                console.print(
+                    f"[bold yellow]⚠️ Failed to initialize Gemini API. Error: {e}[/bold yellow]")
+                self.ai_enabled = False
+        else:
+            self.ai_enabled = False
+
+    def generate_profile(self, df: pd.DataFrame, target_col: str = None) -> str:
+        """
+        Analyzes the dataset and returns data insights.
+        """
+        console.print(
+            "\n[bold brain]🧠 Extracting Smart Insights...[/bold brain]")
+
+        # 1. Compute Local Statistical Metadata (Preserves Data Privacy)
+        summary_stats = {
+            "total_rows": int(df.shape[0]),
+            "total_columns": int(df.shape[1]),
+            "numeric_columns_analysis": {},
+            "target_variable": target_col
+        }
+
+        for col in df.select_dtypes(include=['int64', 'float64']).columns:
+            summary_stats["numeric_columns_analysis"][col] = {
+                "mean": float(df[col].mean()),
+                "skewness": float(df[col].skew()),
+                "correlation_with_target": float(df[col].corr(df[target_col])) if target_col and target_col in df.columns and col != target_col else None
+            }
+
+        # 2. Path A: Generate Contextual AI Insights via LLM
+        if self.ai_enabled:
+            prompt = f"""
+            Act as an elite Data Scientist and ML Engineer. I have calculated summary statistics for a processed dataset:
+            {json.dumps(summary_stats, indent=2)}
+            
+            Provide an executive summary highlighting key data patterns, unexpected distributions, and strategic recommendations for building a predictive model. 
+            Keep it clear, impactful, and under 4 sentences. Do not mention JSON or raw code.
+            """
+            try:
+                # Upgraded Generation Method: Accessed via client.models
+                response = self.client.models.generate_content(
+                    model='gemini-2.5-flash',
+                    contents=prompt
+                )
+                insight_text = response.text.strip()
+                self._display_panel(
+                    insight_text, title="🤖 AI-Generated Strategic Insights")
+                return insight_text
+            except Exception as e:
+                console.print(
+                    f"[bold red]❌ LLM Generation failed: {e}. Defaulting to rule engine.[/bold red]")
+
+        # 3. Path B: Fallback Local Statistical Heuristics (Zero-Cost, Offline)
+        fallback_insights = []
+        for col, metrics in summary_stats["numeric_columns_analysis"].items():
+            if abs(metrics["skewness"]) > 1.0:
+                fallback_insights.append(
+                    f"• [bold cyan]{col}[/bold cyan] shows high distribution skewness ({metrics['skewness']:.2f}). Consider a log transform.")
+            if metrics["correlation_with_target"] and abs(metrics["correlation_with_target"]) > 0.5:
+                fallback_insights.append(
+                    f"• Strong linear relationship detected between [bold cyan]{col}[/bold cyan] and target ({metrics['correlation_with_target']:.2f}).")
+
+        if not fallback_insights:
+            fallback_insights.append(
+                "• Columns show highly stable distributions. Data is well-structured for baseline estimators.")
+
+        insight_text = "\n".join(fallback_insights)
+        self._display_panel(insight_text, title="📊 Local Statistical Insights")
+        return insight_text
+
+    def _display_panel(self, text: str, title: str):
+        console.print(Panel(
+            text,
+            title=title,
+            border_style="purple",
+            expand=False
+        ))

intelaish-0.1.0/intelaish/models.py

@@ -0,0 +1,75 @@
+import pandas as pd
+from rich.console import Console
+from rich.panel import Panel
+
+console = Console()
+
+
+def problem_card(df: pd.DataFrame, target: str):
+    """
+    Analyzes the target variable to determine the ML problem type (Classification/Regression),
+    checks for class imbalances, and recommends baseline machine learning models.
+    """
+    console.print(
+        f"\n[bold yellow]🎯 Generating ML Problem Card for target: '{target}'[/bold yellow]")
+
+    if target not in df.columns:
+        console.print(
+            f"[bold red]❌ Error: Target column '{target}' not found in dataset.[/bold red]")
+        return
+
+    target_data = df[target]
+    unique_vals = target_data.nunique()
+    dtype = target_data.dtype
+
+    # 1. Determine Problem Type Heuristics
+    problem_type = "Unknown"
+    recommended_models = []
+    imbalance_warning = ""
+
+    # If it's numeric and has a wide spread of unique values, it's likely Regression
+    if dtype in ['int64', 'float64'] and unique_vals > 15:
+        problem_type = "Regression 📈"
+        recommended_models = [
+            "Linear Regression (Baseline)",
+            "Random Forest Regressor (Non-linear)",
+            "XGBoost Regressor (Advanced)"
+        ]
+        imbalance_warning = "[bold green]ℹ️ Continuous target detected. Class imbalance does not apply.[/bold green]"
+
+    # Otherwise, it's Classification
+    else:
+        problem_type = "Classification 🗂️"
+        recommended_models = [
+            "Logistic Regression (Baseline)",
+            "Random Forest Classifier (Robust)",
+            "Gradient Boosting / LightGBM (Advanced)"
+        ]
+
+        # 2. Check for Class Imbalance (Crucial ML step)
+        value_counts = target_data.value_counts(normalize=True)
+        min_class_ratio = value_counts.min()
+
+        if min_class_ratio < 0.2:  # If the smallest class makes up less than 20% of data
+            imbalance_warning = f"[bold red]⚠️ Warning: Severe Class Imbalance Detected![/bold red]\n   Smallest class is only {min_class_ratio*100:.1f}% of the dataset.\n   Consider SMOTE, oversampling, or class weighting before training."
+        else:
+            imbalance_warning = f"[bold green]✅ Class distribution is relatively balanced. Safe to proceed.[/bold green]"
+
+    # 3. Build and Display the UI Panel
+    report = (
+        f"[bold]Target Variable:[/bold] {target}\n"
+        f"[bold]Problem Type Detected:[/bold] {problem_type}\n"
+        f"[bold]Unique Classes/Values:[/bold] {unique_vals}\n\n"
+        f"{imbalance_warning}\n\n"
+        f"[bold cyan]🤖 Recommended ML Models:[/bold cyan]\n"
+    )
+
+    for i, model in enumerate(recommended_models, 1):
+        report += f"  {i}. {model}\n"
+
+    console.print(Panel(
+        report,
+        title="📊 intelguruai ML Problem Card",
+        border_style="yellow",
+        expand=False
+    ))

intelaish-0.1.0/intelaish/sql_engine.py

@@ -0,0 +1,56 @@
+import pandas as pd
+from google import genai
+from rich.console import Console
+from rich.panel import Panel
+
+console = Console()
+
+
+class SQLBridge:
+    def __init__(self, api_key: str = None):
+        self.api_key = api_key
+        if api_key:
+            try:
+                self.client = genai.Client(api_key=api_key)
+                self.ai_enabled = True
+            except Exception:
+                self.ai_enabled = False
+        else:
+            self.ai_enabled = False
+
+    def generate_schema(self, df: pd.DataFrame, table_name: str = "dataset") -> str:
+        """Translates a Pandas DataFrame into a SQL CREATE TABLE schema."""
+        schema = f"CREATE TABLE {table_name} (\n"
+        for col, dtype in df.dtypes.items():
+            sql_type = "FLOAT" if dtype in [
+                'float64'] else "INT" if dtype in ['int64'] else "VARCHAR(255)"
+            schema += f"    {col} {sql_type},\n"
+        schema = schema.rstrip(",\n") + "\n);"
+        return schema
+
+    def text_to_sql(self, df: pd.DataFrame, question: str, table_name: str = "dataset"):
+        """Uses AI to translate a plain English question into a SQL query based on the dataframe schema."""
+        console.print(
+            f"\n[bold blue]🗄️ Translating Question to SQL...[/bold blue]")
+        schema = self.generate_schema(df, table_name)
+
+        if not self.ai_enabled:
+            console.print(
+                "[bold red]❌ AI not enabled. Please provide a Gemini API key to use the SQL Bridge.[/bold red]")
+            return
+
+        prompt = f"Given the following SQL schema:\n{schema}\n\nWrite a SQL query to answer this question: '{question}'. Return ONLY the raw SQL code. Do not include markdown formatting or explanations."
+
+        try:
+            response = self.client.models.generate_content(
+                model='gemini-2.5-flash', contents=prompt)
+            sql_query = response.text.strip().replace("```sql", "").replace("```", "")
+
+            console.print(Panel(
+                f"[bold green]Question:[/bold green] {question}\n\n[bold cyan]Generated SQL Query:[/bold cyan]\n{sql_query}",
+                title="🤖 intelguruai SQL Bridge",
+                border_style="blue",
+                expand=False
+            ))
+        except Exception as e:
+            console.print(f"[bold red]❌ SQL Generation failed: {e}[/bold red]")

intelaish-0.1.0/intelaish/visuals.py

@@ -0,0 +1,91 @@
+import pandas as pd
+import plotly.express as px
+from rich.console import Console
+from sklearn.cluster import KMeans
+import plotly.graph_objects as go
+
+console = Console()
+
+
+def smart_viz(df: pd.DataFrame, target: str = None):
+    """
+    Automatically analyzes the dataset columns and generates 
+    the most relevant interactive Plotly charts.
+    """
+    console.print(
+        "\n[bold cyan]🎨 Launching Automated Visualization Engine...[/bold cyan]")
+
+    # Separate numeric and categorical columns
+    numeric_cols = df.select_dtypes(
+        include=['int64', 'float64']).columns.tolist()
+    categorical_cols = df.select_dtypes(
+        include=['object', 'category']).columns.tolist()
+
+    # 1. Plot Distributions for Numeric Columns
+    for col in numeric_cols:
+        console.print(
+            f"📈 Generating distribution plot for numeric feature: [bold cyan]{col}[/bold cyan]")
+        fig = px.histogram(
+            df,
+            x=col,
+            marginal="box",
+            title=f"Distribution of {col}",
+            template="plotly_dark",
+            color_discrete_sequence=['#00ffcc']
+        )
+        fig.show()
+
+    # 2. Plot Counts for Categorical Columns
+    for col in categorical_cols:
+        console.print(
+            f"📊 Generating bar chart for categorical feature: [bold magenta]{col}[/bold magenta]")
+        fig = px.bar(
+            df,
+            x=col,
+            title=f"Value Counts of {col}",
+            template="plotly_dark",
+            color_discrete_sequence=['#ff007f']  # Fix applied here!
+        )
+        fig.show()
+
+    # 3. Relationship Plot (If a target column is provided)
+    if target and target in df.columns:
+        console.print(
+            f"🎯 Target variable specified. Generating relationship plots for: [bold yellow]{target}[/bold yellow]")
+        for col in numeric_cols:
+            if col != target:
+                fig = px.scatter(
+                    df,
+                    x=col,
+                    y=target,
+                    trendline="ols",
+                    title=f"Relationship: {col} vs {target}",
+                    template="plotly_dark"
+                )
+                fig.show()
+
+
+def advanced_viz(df: pd.DataFrame, n_clusters: int = 3):
+    """Generates a 3D interactive scatter plot."""
+    console.print(
+        "\n[bold cyan]🚀 Generating 3D Cluster Visualizations...[/bold cyan]")
+    numeric_df = df.select_dtypes(include=['int64', 'float64']).dropna()
+
+    if numeric_df.shape[1] < 3:
+        console.print(
+            "[bold red]❌ Need at least 3 numeric columns for 3D visualization.[/bold red]")
+        return
+
+    kmeans = KMeans(n_clusters=n_clusters, n_init=10, random_state=42)
+    clusters = kmeans.fit_predict(numeric_df)
+
+    cols = numeric_df.columns
+    fig = go.Figure(data=[go.Scatter3d(
+        x=numeric_df[cols[0]], y=numeric_df[cols[1]], z=numeric_df[cols[2]],
+        mode='markers', marker=dict(size=8, color=clusters, colorscale='Viridis', opacity=0.8)
+    )])
+
+    fig.update_layout(title="3D Cluster Visualization", template="plotly_dark")
+    console.print(
+        "[bold green]✅ 3D Cluster Visualization Generated![/bold green]")
+    fig.show()

intelaish-0.1.0/intelaish.egg-info/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: intelaish
+Version: 0.1.0
+Summary: Next-generation automated EDA, cleaning, and AI insights.
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: pandas>=2.0.0
+Requires-Dist: numpy>=1.24.0
+Requires-Dist: plotly>=5.14.0
+Requires-Dist: scikit-learn>=1.2.0
+Requires-Dist: google-genai>=0.2.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: statsmodels>=0.14.0
+Requires-Dist: shap>=0.42.0
+Requires-Dist: matplotlib>=3.7.0

intelaish-0.1.0/intelaish.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+README.md
+pyproject.toml
+intelaish/__init__.py
+intelaish/cleaning.py
+intelaish/explain.py
+intelaish/ingestion.py
+intelaish/insights.py
+intelaish/models.py
+intelaish/sql_engine.py
+intelaish/visuals.py
+intelaish.egg-info/PKG-INFO
+intelaish.egg-info/SOURCES.txt
+intelaish.egg-info/dependency_links.txt
+intelaish.egg-info/requires.txt
+intelaish.egg-info/top_level.txt

intelaish-0.1.0/intelaish.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

intelaish-0.1.0/intelaish.egg-info/requires.txt

@@ -0,0 +1,9 @@
+pandas>=2.0.0
+numpy>=1.24.0
+plotly>=5.14.0
+scikit-learn>=1.2.0
+google-genai>=0.2.0
+rich>=13.0.0
+statsmodels>=0.14.0
+shap>=0.42.0
+matplotlib>=3.7.0

intelaish-0.1.0/intelaish.egg-info/top_level.txt

@@ -0,0 +1 @@
+intelaish

intelaish-0.1.0/pyproject.toml

@@ -0,0 +1,21 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "intelaish"
+version = "0.1.0"
+description = "Next-generation automated EDA, cleaning, and AI insights."
+readme = "README.md"
+requires-python = ">=3.8"
+dependencies = [
+    "pandas>=2.0.0",
+    "numpy>=1.24.0",
+    "plotly>=5.14.0",
+    "scikit-learn>=1.2.0",
+    "google-genai>=0.2.0",
+    "rich>=13.0.0",
+    "statsmodels>=0.14.0",
+    "shap>=0.42.0",
+    "matplotlib>=3.7.0"
+]

intelaish-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+