lazyanalyst 1.0.0__py3-none-any.whl

lazyanalyst/__init__.py

@@ -0,0 +1 @@
+from .analyze import analyze, LazyAnalystResult

lazyanalyst/analyze.py

@@ -0,0 +1,204 @@
+import os
+from . import loader
+from . import schema
+from . import quality
+from . import cleaner
+from . import eda
+from . import visualizer
+from . import features
+from . import stats
+from . import insights
+from . import dashboard
+from . import reporter
+
+class LazyAnalystResult:
+    """result object returned by analyze"""
+    def __init__(self, cleaned_data_path, report_path, dashboard_path, cleaned_df):
+        self.cleaned_data_path = cleaned_data_path
+        self.report_path = report_path
+        self.dashboard_path = dashboard_path
+        self._cleaned_df = cleaned_df
+    
+    def dashboard(self):
+        """opens dashboard.html in browser"""
+        import webbrowser
+        webbrowser.open(self.dashboard_path)
+    
+    def report(self):
+        """opens report.html in browser"""
+        import webbrowser
+        webbrowser.open(self.report_path)
+    
+    def cleaned_data(self):
+        """returns cleaned pandas DataFrame"""
+        return self._cleaned_df
+
+
+def analyze(filepath, dashboard=True, report=True):
+    """runs full analysis pipeline"""
+    
+    # make sure outputs folder exists
+    if not os.path.exists("outputs"):
+        os.makedirs("outputs")
+        print("[LazyAnalyst] Created outputs/ folder")
+    
+    # store all results in a dict
+    all_results = {
+        "filename": os.path.basename(filepath),
+        "cleaned_df": None,
+        "schema": None,
+        "quality_report": None,
+        "cleaning_actions": [],
+        "eda_results": {},
+        "features_created": [],
+        "stats_results": [],
+        "insights": []
+    }
+    
+    # Module 1 - Loader
+    print("\n[LazyAnalyst] Step 1/11 — Loading dataset...")
+    try:
+        df = loader.load(filepath)
+        if df.empty:
+            raise ValueError("Loaded dataframe is empty")
+        all_results["original_df"] = df
+    except Exception as e:
+        print(f"[LazyAnalyst] Warning: loader failed — {e}. Skipping this step.")
+        return None
+    
+    # Module 2 - Schema
+    print("\n[LazyAnalyst] Step 2/11 — Detecting schema...")
+    try:
+        schema_dict = schema.detect(df)
+        all_results["schema"] = schema_dict
+    except Exception as e:
+        print(f"[LazyAnalyst] Warning: schema detection failed — {e}. Skipping this step.")
+        schema_dict = {}
+        all_results["schema"] = {}
+    
+    # Module 3 - Quality
+    print("\n[LazyAnalyst] Step 3/11 — Auditing data quality...")
+    try:
+        quality_report = quality.audit(df, schema_dict)
+        all_results["quality_report"] = quality_report
+    except Exception as e:
+        print(f"[LazyAnalyst] Warning: quality audit failed — {e}. Skipping this step.")
+        quality_report = {"score": 0, "missing": {}, "duplicates": {"count":0,"pct":0}, "outliers": {}, "invalid": []}
+        all_results["quality_report"] = quality_report
+    
+    # Module 4 - Cleaner
+    print("\n[LazyAnalyst] Step 4/11 — Cleaning dataset...")
+    try:
+        cleaned_df, actions = cleaner.clean(df, schema_dict, quality_report)
+        all_results["cleaned_df"] = cleaned_df
+        all_results["cleaning_actions"] = actions
+    except Exception as e:
+        print(f"[LazyAnalyst] Warning: cleaner failed — {e}. Skipping this step.")
+        cleaned_df = df.copy()
+        all_results["cleaned_df"] = cleaned_df
+        all_results["cleaning_actions"] = []
+    
+    # Module 5 - EDA
+    print("\n[LazyAnalyst] Step 5/11 — Running exploratory analysis...")
+    try:
+        eda_results = eda.run(cleaned_df, schema_dict)
+        all_results["eda_results"] = eda_results
+    except Exception as e:
+        print(f"[LazyAnalyst] Warning: EDA failed — {e}. Skipping this step.")
+        all_results["eda_results"] = {"numerical": {}, "categorical": {}, "correlation": {}}
+    
+    # Module 6 - Visualizer
+    print("\n[LazyAnalyst] Step 6/11 — Generating visualizations...")
+    try:
+        visualizer.generate(cleaned_df, schema_dict)
+    except Exception as e:
+        print(f"[LazyAnalyst] Warning: visualizer failed — {e}. Skipping this step.")
+    
+    # Module 7 - Features
+    print("\n[LazyAnalyst] Step 7/11 — Engineering features...")
+    try:
+        df_with_features, feat_list = features.engineer(cleaned_df, schema_dict)
+        all_results["cleaned_df"] = df_with_features  # update df with new features
+        all_results["features_created"] = feat_list
+        # update schema for new columns? not necessary for v1
+    except Exception as e:
+        print(f"[LazyAnalyst] Warning: feature engineering failed — {e}. Skipping this step.")
+        all_results["features_created"] = []
+    
+    # Module 8 - Stats
+    print("\n[LazyAnalyst] Step 8/11 — Running statistical tests...")
+    try:
+        stats_results = stats.run(all_results["cleaned_df"], schema_dict)
+        all_results["stats_results"] = stats_results
+    except Exception as e:
+        print(f"[LazyAnalyst] Warning: stats failed — {e}. Skipping this step.")
+        all_results["stats_results"] = []
+    
+    # Module 9 - Insights
+    print("\n[LazyAnalyst] Step 9/11 — Generating insights...")
+    try:
+        insight_list = insights.generate(
+            all_results["eda_results"],
+            all_results["stats_results"],
+            all_results["quality_report"]
+        )
+        all_results["insights"] = insight_list
+    except Exception as e:
+        print(f"[LazyAnalyst] Warning: insights generation failed — {e}. Skipping this step.")
+        all_results["insights"] = []
+    
+    # Module 10 - Dashboard - FIXED: check dashboard parameter
+    dashboard_path = None
+    if dashboard:
+        print("\n[LazyAnalyst] Step 10/11 — Building dashboard...")
+        dashboard_input = {
+            "cleaned_df": all_results["cleaned_df"],
+            "schema": all_results["schema"],
+            "quality_report": all_results["quality_report"],
+            "eda_results": all_results["eda_results"],
+            "stats_results": all_results["stats_results"],
+            "insights": all_results["insights"],
+            "filename": all_results["filename"]
+        }
+        try:
+            dashboard.build(dashboard_input)
+            dashboard_path = "outputs/dashboard.html"
+        except Exception as e:
+            print(f"[LazyAnalyst] Warning: dashboard failed — {e}. Skipping this step.")
+    else:
+        print("\n[LazyAnalyst] Step 10/11 — Skipping dashboard (disabled)...")
+    
+    # Module 11 - Reporter - FIXED: check report parameter
+    report_path = None
+    if report:
+        print("\n[LazyAnalyst] Step 11/11 — Generating HTML report...")
+        report_input = {
+            "cleaned_df": all_results["cleaned_df"],
+            "schema": all_results["schema"],
+            "quality_report": all_results["quality_report"],
+            "cleaning_actions": all_results["cleaning_actions"],
+            "eda_results": all_results["eda_results"],
+            "features_created": all_results["features_created"],
+            "stats_results": all_results["stats_results"],
+            "insights": all_results["insights"],
+            "filename": all_results["filename"]
+        }
+        try:
+            reporter.build(report_input)
+            report_path = "outputs/report.html"
+        except Exception as e:
+            print(f"[LazyAnalyst] Warning: reporter failed — {e}. Skipping this step.")
+    else:
+        print("\n[LazyAnalyst] Step 11/11 — Skipping report (disabled)...")
+    
+    print("\n[LazyAnalyst] Analysis complete!")
+    print(f"[LazyAnalyst] Outputs saved to ./outputs/")
+    
+    # return result object
+    cleaned_data_path = "outputs/cleaned_data.csv"
+    return LazyAnalystResult(
+        cleaned_data_path=cleaned_data_path,
+        report_path=report_path if report_path else "",
+        dashboard_path=dashboard_path if dashboard_path else "",
+        cleaned_df=all_results["cleaned_df"]
+    )

lazyanalyst/cleaner.py

@@ -0,0 +1,89 @@
+import pandas as pd
+import numpy as np
+import os
+
+def clean(df, schema, quality_report):
+    """cleans the dataset and returns cleaned df and actions list"""
+    
+    actions = []
+    df_clean = df.copy()
+    
+    # make outputs folder if needed
+    if not os.path.exists("outputs"):
+        os.makedirs("outputs")
+    
+    # 1. Remove duplicate rows
+    before = len(df_clean)
+    df_clean = df_clean.drop_duplicates()
+    after = len(df_clean)
+    removed = before - after
+    if removed > 0:
+        actions.append(f"Removed {removed} duplicate rows")
+        print(f"[LazyAnalyst] Removed {removed} duplicate rows")
+    
+    # 2. Fill missing values
+    for col in df_clean.columns:
+        missing_count = df_clean[col].isna().sum()
+        if missing_count == 0:
+            continue
+        
+        col_type = schema.get(col, 'categorical')
+        
+        # numerical -> median
+        if col_type == 'numerical':
+            median_val = df_clean[col].median()
+            # FIXED: use assignment instead of inplace=True for pandas 3.x CoW
+            df_clean[col] = df_clean[col].fillna(median_val)
+            actions.append(f"Filled {missing_count} missing values in '{col}' with median ({median_val:.2f})")
+            print(f"[LazyAnalyst] Filled {missing_count} missing in '{col}' with median")
+        
+        # categorical -> mode
+        elif col_type == 'categorical':
+            mode_val = df_clean[col].mode()
+            if len(mode_val) > 0:
+                mode_val = mode_val[0]
+                # FIXED: use assignment instead of inplace=True
+                df_clean[col] = df_clean[col].fillna(mode_val)
+                actions.append(f"Filled {missing_count} missing values in '{col}' with mode ({mode_val})")
+                print(f"[LazyAnalyst] Filled {missing_count} missing in '{col}' with mode")
+            else:
+                # fallback if no mode
+                df_clean[col] = df_clean[col].fillna("unknown")
+                actions.append(f"Filled {missing_count} missing values in '{col}' with 'unknown'")
+        
+        # datetime -> leave as-is (do nothing)
+        elif col_type == 'datetime':
+            actions.append(f"Left {missing_count} missing values in datetime column '{col}' as-is")
+    
+    # 3. Parse datetime columns
+    for col in df_clean.columns:
+        if schema.get(col) == 'datetime':
+            try:
+                df_clean[col] = pd.to_datetime(df_clean[col], errors='coerce')
+                actions.append(f"Parsed datetime column: '{col}'")
+                print(f"[LazyAnalyst] Parsed datetime column: '{col}'")
+            except Exception as e:
+                actions.append(f"Warning: could not parse datetime column '{col}'")
+                print(f"[LazyAnalyst] Warning: could not parse datetime column '{col}'")
+    
+    # 4. Flag outliers - FIXED: use is_numeric_dtype
+    for col in df_clean.columns:
+        if schema.get(col) == 'numerical' and pd.api.types.is_numeric_dtype(df_clean[col]):
+            q1 = df_clean[col].quantile(0.25)
+            q3 = df_clean[col].quantile(0.75)
+            iqr = q3 - q1
+            lower = q1 - 1.5 * iqr
+            upper = q3 + 1.5 * iqr
+            outlier_flag = (df_clean[col] < lower) | (df_clean[col] > upper)
+            col_name_outlier = f"{col}_is_outlier"
+            df_clean[col_name_outlier] = outlier_flag
+            outlier_count = outlier_flag.sum()
+            if outlier_count > 0:
+                actions.append(f"Flagged outliers in column: '{col}' ({outlier_count} rows)")
+                print(f"[LazyAnalyst] Flagged outliers in column: '{col}' ({outlier_count} rows)")
+    
+    # save cleaned data
+    df_clean.to_csv("outputs/cleaned_data.csv", index=False)
+    print(f"[LazyAnalyst] Saved cleaned data to outputs/cleaned_data.csv")
+    
+    return df_clean, actions

lazyanalyst/dashboard.py

@@ -0,0 +1,233 @@
+import pandas as pd
+import numpy as np
+import plotly.express as px
+import plotly.graph_objects as go
+import os
+
+def build(all_results):
+    """builds and saves self-contained dashboard HTML"""
+    
+    # unpack results (this is messy but works)
+    cleaned_df = all_results.get("cleaned_df")
+    schema = all_results.get("schema")
+    quality_report = all_results.get("quality_report")
+    eda_results = all_results.get("eda_results")
+    stats_results = all_results.get("stats_results")
+    insights_list = all_results.get("insights")
+    
+    if cleaned_df is None:
+        print("[LazyAnalyst] Warning: no cleaned dataframe for dashboard")
+        return
+    
+    # get dataset info
+    filename = all_results.get("filename", "dataset")
+    n_rows = len(cleaned_df)
+    n_cols = len(cleaned_df.columns)
+    quality_score = quality_report.get("score", 0) if quality_report else 0
+    
+    # start building HTML
+    html_parts = []
+    html_parts.append("""
+    <!DOCTYPE html>
+    <html>
+    <head>
+        <meta charset="UTF-8">
+        <title>LazyAnalyst Dashboard</title>
+        <style>
+            body {
+                background-color: #0f1117;
+                color: #e0e0e0;
+                font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Helvetica, Arial, sans-serif;
+                margin: 0;
+                padding: 20px;
+            }
+            .container {
+                max-width: 1400px;
+                margin: 0 auto;
+            }
+            h1, h2, h3 {
+                color: #4fc3f7;
+            }
+            h1 {
+                border-bottom: 2px solid #4fc3f7;
+                padding-bottom: 10px;
+            }
+            .section {
+                margin-bottom: 40px;
+                background: #1a1c23;
+                padding: 20px;
+                border-radius: 8px;
+            }
+            .metric {
+                display: inline-block;
+                background: #2a2c35;
+                padding: 10px 20px;
+                border-radius: 6px;
+                margin-right: 15px;
+                margin-bottom: 10px;
+            }
+            table {
+                width: 100%;
+                border-collapse: collapse;
+                margin-top: 15px;
+            }
+            th, td {
+                text-align: left;
+                padding: 10px;
+                border-bottom: 1px solid #333;
+            }
+            th {
+                background-color: #2a2c35;
+                color: #4fc3f7;
+            }
+            .insight-list {
+                list-style-type: none;
+                padding-left: 0;
+            }
+            .insight-list li {
+                background: #2a2c35;
+                margin: 10px 0;
+                padding: 12px;
+                border-radius: 6px;
+                border-left: 4px solid #4fc3f7;
+            }
+            .chart-container {
+                margin: 20px 0;
+                padding: 10px;
+                background: #1a1c23;
+                border-radius: 6px;
+            }
+            .two-column {
+                display: flex;
+                gap: 20px;
+                flex-wrap: wrap;
+            }
+            .two-column > div {
+                flex: 1;
+                min-width: 300px;
+            }
+        </style>
+    </head>
+    <body>
+    <div class="container">
+        <h1>LazyAnalyst Dashboard</h1>
+    """)
+    
+    # 1. Overview section
+    html_parts.append(f"""
+        <div class="section">
+            <h2>Overview</h2>
+            <div class="metric">📄 Dataset: {filename}</div>
+            <div class="metric">📊 Rows: {n_rows}</div>
+            <div class="metric">📋 Columns: {n_cols}</div>
+            <div class="metric">⭐ Quality Score: {quality_score}/100</div>
+            <h3>Columns & Types</h3>
+            <table>
+                <tr><th>Column Name</th><th>Detected Type</th></tr>
+    """)
+    
+    if schema:
+        for col, col_type in schema.items():
+            html_parts.append(f"<tr><td>{col}</td><td>{col_type}</td></tr>")
+    html_parts.append("</table></div>")
+    
+    # 2. Data Quality section
+    missing_data = quality_report.get("missing", {}) if quality_report else {}
+    dup_info = quality_report.get("duplicates", {"count":0, "pct":0}) if quality_report else {"count":0, "pct":0}
+    outliers_info = quality_report.get("outliers", {}) if quality_report else {}
+    
+    # missing values bar chart (plotly)
+    if missing_data:
+        missing_cols = list(missing_data.keys())
+        missing_pcts = [missing_data[c]["pct"] for c in missing_cols]
+        fig_missing = px.bar(x=missing_cols, y=missing_pcts, labels={'x':'Column', 'y':'Missing (%)'}, title="Missing Values by Column")
+        fig_missing.update_layout(template="plotly_dark", paper_bgcolor="#1a1c23", plot_bgcolor="#1a1c23")
+        html_parts.append(f"""
+        <div class="section">
+            <h2>Data Quality</h2>
+            <div class="chart-container">
+                {fig_missing.to_html(full_html=False, include_plotlyjs='cdn')}
+            </div>
+            <p>Duplicate rows: {dup_info['count']} ({dup_info['pct']}%)</p>
+            <p>Outliers flagged in columns: {', '.join(outliers_info.keys()) if outliers_info else 'none'}</p>
+        </div>
+        """)
+    else:
+        html_parts.append(f"""
+        <div class="section">
+            <h2>Data Quality</h2>
+            <p>No missing values found.</p>
+            <p>Duplicate rows: {dup_info['count']} ({dup_info['pct']}%)</p>
+            <p>Outliers flagged in columns: {', '.join(outliers_info.keys()) if outliers_info else 'none'}</p>
+        </div>
+        """)
+    
+    # 3. Distributions
+    num_cols = [col for col in schema if schema[col]=='numerical'] if schema else []
+    cat_cols = [col for col in schema if schema[col]=='categorical'] if schema else []
+    
+    html_parts.append('<div class="section"><h2>Distributions</h2>')
+    # histograms for numerical
+    for col in num_cols[:5]:  # limit to 5
+        fig_hist = px.histogram(cleaned_df, x=col, nbins=30, title=f"Distribution of {col}", template="plotly_dark")
+        fig_hist.update_layout(paper_bgcolor="#1a1c23", plot_bgcolor="#1a1c23")
+        html_parts.append(f'<div class="chart-container">{fig_hist.to_html(full_html=False, include_plotlyjs="cdn")}</div>')
+    
+    # bar charts for categorical (top 10)
+    for col in cat_cols[:5]:
+        top10 = cleaned_df[col].value_counts().nlargest(10).reset_index()
+        top10.columns = [col, 'count']
+        fig_bar = px.bar(top10, x=col, y='count', title=f"Top 10 categories in {col}", template="plotly_dark")
+        fig_bar.update_layout(paper_bgcolor="#1a1c23", plot_bgcolor="#1a1c23")
+        html_parts.append(f'<div class="chart-container">{fig_bar.to_html(full_html=False, include_plotlyjs="cdn")}</div>')
+    html_parts.append('</div>')
+    
+    # 4. Correlations (heatmap)
+    if len(num_cols) >= 2:
+        corr_matrix = cleaned_df[num_cols].corr()
+        fig_corr = go.Figure(data=go.Heatmap(z=corr_matrix.values, x=corr_matrix.columns, y=corr_matrix.columns, colorscale='RdBu', zmid=0))
+        fig_corr.update_layout(title="Correlation Heatmap", template="plotly_dark", paper_bgcolor="#1a1c23", plot_bgcolor="#1a1c23")
+        html_parts.append(f"""
+        <div class="section">
+            <h2>Correlations</h2>
+            <div class="chart-container">{fig_corr.to_html(full_html=False, include_plotlyjs='cdn')}</div>
+        </div>
+        """)
+    
+    # 5. Statistical Tests (table)
+    html_parts.append('<div class="section"><h2>Statistical Tests</h2>')
+    if stats_results:
+        html_parts.append("""
+        <table>
+            <tr><th>Test</th><th>Columns</th><th>p-value</th><th>Significant</th><th>Interpretation</th></tr>
+        """)
+        for stat in stats_results:
+            test = stat.get("test", "")
+            cols = ", ".join(stat.get("columns", []))
+            p_val = stat.get("p_value", 1)
+            sig = "Yes" if stat.get("significant", False) else "No"
+            interp = stat.get("interpretation", "")
+            html_parts.append(f"<tr><td>{test}</td><td>{cols}</td><td>{p_val}</td><td>{sig}</td><td>{interp}</td></tr>")
+        html_parts.append("</table>")
+    else:
+        html_parts.append("<p>No statistical tests were run.</p>")
+    html_parts.append('</div>')
+    
+    # 6. Insights
+    html_parts.append('<div class="section"><h2>Insights</h2><ul class="insight-list">')
+    if insights_list:
+        for ins in insights_list:
+            html_parts.append(f"<li>{ins}</li>")
+    else:
+        html_parts.append("<li>No insights generated.</li>")
+    html_parts.append("</ul></div>")
+    
+    html_parts.append("</div></body></html>")
+    
+    # write to file
+    full_html = "".join(html_parts)
+    if not os.path.exists("outputs"):
+        os.makedirs("outputs")
+    with open("outputs/dashboard.html", "w", encoding="utf-8") as f:
+        f.write(full_html)
+    print("[LazyAnalyst] Dashboard saved to outputs/dashboard.html")

lazyanalyst/eda.py

@@ -0,0 +1,72 @@
+import pandas as pd
+import numpy as np
+from scipy.stats import skew
+
+def run(df, schema):
+    """generates summary statistics and correlation matrix"""
+    
+    eda_results = {
+        "numerical": {},
+        "categorical": {},
+        "correlation": {}
+    }
+    
+    # get numerical columns
+    num_cols = [col for col in df.columns if schema.get(col) == 'numerical']
+    cat_cols = [col for col in df.columns if schema.get(col) == 'categorical']
+    
+    # 1. Numerical summary - FIXED: use is_numeric_dtype
+    for col in num_cols:
+        if col in df.columns and pd.api.types.is_numeric_dtype(df[col]):
+            data = df[col].dropna()
+            if len(data) > 0:
+                # using .iloc and .loc mix
+                q1_val = data.quantile(0.25)
+                q3_val = data.quantile(0.75)
+                skewness = skew(data) if len(data) > 2 else 0
+                
+                eda_results["numerical"][col] = {
+                    "mean": round(data.mean(), 4),
+                    "median": round(data.median(), 4),
+                    "std": round(data.std(), 4),
+                    "variance": round(data.var(), 4),
+                    "min": round(data.min(), 4),
+                    "max": round(data.max(), 4),
+                    "Q1": round(q1_val, 4),
+                    "Q3": round(q3_val, 4),
+                    "skewness": round(skewness, 4)
+                }
+    
+    # 2. Categorical summary
+    for col in cat_cols:
+        if col in df.columns:
+            data = df[col].dropna()
+            if len(data) > 0:
+                value_counts = data.value_counts()
+                top5 = value_counts.head(5).to_dict()
+                # convert top5 keys to string in case they are numbers
+                top5_str = {str(k): v for k, v in top5.items()}
+                
+                eda_results["categorical"][col] = {
+                    "unique": data.nunique(),
+                    "top": top5_str
+                }
+    
+    # 3. Correlation matrix (Pearson) for numerical columns
+    if len(num_cols) >= 2:
+        # make sure all exist and are numeric
+        num_cols_exist = [c for c in num_cols if c in df.columns and pd.api.types.is_numeric_dtype(df[c])]
+        if len(num_cols_exist) >= 2:
+            corr_matrix = df[num_cols_exist].corr()
+            # convert to nested dict
+            corr_dict = {}
+            for i in corr_matrix.index:
+                corr_dict[i] = {}
+                for j in corr_matrix.columns:
+                    if i != j:
+                        corr_dict[i][j] = round(corr_matrix.loc[i, j], 4)
+            eda_results["correlation"] = corr_dict
+    
+    print(f"[LazyAnalyst] EDA complete: {len(num_cols)} numerical, {len(cat_cols)} categorical columns analyzed")
+    
+    return eda_results

lazyanalyst/features.py

@@ -0,0 +1,67 @@
+import pandas as pd
+import numpy as np
+from scipy.stats import skew
+
+def engineer(df, schema):
+    """adds new features to the dataframe"""
+    
+    df_new = df.copy()
+    features_created = []
+    
+    # 1. From datetime columns
+    for col in df_new.columns:
+        if schema.get(col) == 'datetime':
+            try:
+                # ensure it's datetime
+                if not pd.api.types.is_datetime64_any_dtype(df_new[col]):
+                    df_new[col] = pd.to_datetime(df_new[col], errors='coerce')
+                
+                # extract components
+                df_new[f'{col}_year'] = df_new[col].dt.year
+                df_new[f'{col}_month'] = df_new[col].dt.month
+                df_new[f'{col}_day'] = df_new[col].dt.day
+                df_new[f'{col}_quarter'] = df_new[col].dt.quarter
+                df_new[f'{col}_weekday'] = df_new[col].dt.weekday
+                df_new[f'{col}_is_weekend'] = (df_new[col].dt.weekday >= 5).astype(int)
+                
+                features_created.append(f"Created {col}_year")
+                features_created.append(f"Created {col}_month")
+                features_created.append(f"Created {col}_day")
+                features_created.append(f"Created {col}_quarter")
+                features_created.append(f"Created {col}_weekday")
+                features_created.append(f"Created {col}_is_weekend")
+                
+                print(f"[LazyAnalyst] Added datetime features from '{col}'")
+            except Exception as e:
+                print(f"[LazyAnalyst] Warning: could not extract datetime features from {col} - {e}")
+    
+    # 2. From categorical columns (label encoding)
+    for col in df_new.columns:
+        if schema.get(col) == 'categorical':
+            try:
+                # use pd.factorize for label encoding
+                encoded, _ = pd.factorize(df_new[col])
+                df_new[f'{col}_encoded'] = encoded
+                features_created.append(f"Created {col}_encoded")
+                print(f"[LazyAnalyst] Label encoded '{col}'")
+            except Exception as e:
+                print(f"[LazyAnalyst] Warning: could not encode {col} - {e}")
+    
+    # 3. From numerical columns (log transform if skewed)
+    for col in df_new.columns:
+        if schema.get(col) == 'numerical':
+            # check skewness
+            data = df_new[col].dropna()
+            if len(data) > 2:
+                skew_val = skew(data)
+                if abs(skew_val) > 1.0:
+                    try:
+                        # using np.log1p to handle zeros
+                        df_new[f'{col}_log'] = np.log1p(df_new[col])
+                        features_created.append(f"Created {col}_log")
+                        print(f"[LazyAnalyst] Added log transform for '{col}' (skewness={skew_val:.2f})")
+                    except Exception as e:
+                        print(f"[LazyAnalyst] Warning: could not log transform {col} - {e}")
+    
+    print(f"[LazyAnalyst] Total new features created: {len(features_created)}")
+    return df_new, features_created