sol-ai-core 0.1.0__tar.gz

sol_ai_core-0.1.0/PKG-INFO

@@ -0,0 +1,77 @@
+Metadata-Version: 2.4
+Name: sol-ai-core
+Version: 0.1.0
+Summary: A professional Python Library for automated data cleaning, model selection, and visualization.
+Project-URL: Homepage, https://github.com/yourusername/sol-ai-core
+Author-email: Your Name <your.email@example.com>
+License: MIT
+Requires-Python: >=3.8
+Requires-Dist: matplotlib>=3.4.0
+Requires-Dist: openai>=1.0.0
+Requires-Dist: pandas>=1.3.0
+Requires-Dist: scikit-learn>=1.0.0
+Description-Content-Type: text/markdown
+
+# sol-ai-core
+
+**SOL Engine** is now `sol-ai-core`, a professional, environment-agnostic Python library for automated data cleaning, machine learning model selection, and visualization.
+
+## Features
+- **Logic Separated:** Works seamlessly in any Python environment (Jupyter, VS Code, CI/CD) without requiring Streamlit.
+- **Class-Based Design:** Easy to use object-oriented approach.
+- **End-to-End Automation:** Pass a DataFrame, auto-clean it, train models, and generate insights in just a few lines of code.
+
+## Installation
+
+You can install the package via pip once published to PyPI:
+
+```bash
+pip install sol-ai-core
+```
+
+For local development:
+
+```bash
+git clone https://github.com/yourusername/sol-ai-core.git
+cd sol-ai-core
+pip install -e .
+```
+
+## Usage
+
+```python
+import pandas as pd
+from sol_core.engine import SolEngine
+
+# 1. Load your data
+df = pd.read_csv("data.csv")
+
+# 2. Initialize the engine
+engine = SolEngine(df)
+
+# 3. Clean the data automatically
+clean_df = engine.auto_clean()
+
+# 4. Train a model automatically (Classification or Regression)
+report = engine.select_and_train_model(target_column="target")
+print(report)
+
+# 5. Generate Visualizations (Returns Matplotlib figure objects)
+figures = engine.generate_visualizations(target_column="target")
+figures['target_distribution'].show()
+```
+
+## Publishing to PyPI
+
+To build and publish this library to PyPI, use the following commands:
+
+```bash
+# Install build tools and twine
+pip install build twine
+
+# Build the package (creates dist/ directory)
+python -m build
+
+# Upload to PyPI (will prompt for username and password/token)
+python -m twine upload dist/*
+```

sol_ai_core-0.1.0/README.md

@@ -0,0 +1,63 @@
+# sol-ai-core
+
+**SOL Engine** is now `sol-ai-core`, a professional, environment-agnostic Python library for automated data cleaning, machine learning model selection, and visualization.
+
+## Features
+- **Logic Separated:** Works seamlessly in any Python environment (Jupyter, VS Code, CI/CD) without requiring Streamlit.
+- **Class-Based Design:** Easy to use object-oriented approach.
+- **End-to-End Automation:** Pass a DataFrame, auto-clean it, train models, and generate insights in just a few lines of code.
+
+## Installation
+
+You can install the package via pip once published to PyPI:
+
+```bash
+pip install sol-ai-core
+```
+
+For local development:
+
+```bash
+git clone https://github.com/yourusername/sol-ai-core.git
+cd sol-ai-core
+pip install -e .
+```
+
+## Usage
+
+```python
+import pandas as pd
+from sol_core.engine import SolEngine
+
+# 1. Load your data
+df = pd.read_csv("data.csv")
+
+# 2. Initialize the engine
+engine = SolEngine(df)
+
+# 3. Clean the data automatically
+clean_df = engine.auto_clean()
+
+# 4. Train a model automatically (Classification or Regression)
+report = engine.select_and_train_model(target_column="target")
+print(report)
+
+# 5. Generate Visualizations (Returns Matplotlib figure objects)
+figures = engine.generate_visualizations(target_column="target")
+figures['target_distribution'].show()
+```
+
+## Publishing to PyPI
+
+To build and publish this library to PyPI, use the following commands:
+
+```bash
+# Install build tools and twine
+pip install build twine
+
+# Build the package (creates dist/ directory)
+python -m build
+
+# Upload to PyPI (will prompt for username and password/token)
+python -m twine upload dist/*
+```

sol_ai_core-0.1.0/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "sol-ai-core"
+version = "0.1.0"
+description = "A professional Python Library for automated data cleaning, model selection, and visualization."
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "MIT" }
+authors = [
+    { name = "Your Name", email = "your.email@example.com" }
+]
+dependencies = [
+    "pandas>=1.3.0",
+    "scikit-learn>=1.0.0",
+    "matplotlib>=3.4.0",
+    "openai>=1.0.0"
+]
+
+[project.urls]
+Homepage = "https://github.com/yourusername/sol-ai-core"
+
+[tool.hatch.build.targets.wheel]
+packages = ["sol_core"]
+

sol_ai_core-0.1.0/sol_core/__init__.py

@@ -0,0 +1,3 @@
+from .engine import SolEngine
+
+__all__ = ["SolEngine"]

sol_ai_core-0.1.0/sol_core/engine.py

@@ -0,0 +1,154 @@
+import pandas as pd
+import numpy as np
+from sklearn.model_selection import train_test_split
+from sklearn.ensemble import RandomForestRegressor, RandomForestClassifier
+from sklearn.metrics import mean_squared_error, accuracy_score
+import matplotlib.pyplot as plt
+import openai
+
+class SolEngine:
+    def __init__(self, df: pd.DataFrame):
+        """
+        Initializes the SolEngine with a Pandas DataFrame.
+        """
+        self.raw_df = df.copy()
+        self.clean_df = None
+        self.model = None
+        self.report = None
+        self.figures = {}
+        
+    def auto_clean(self) -> pd.DataFrame:
+        """
+        Automatically cleans the DataFrame by:
+        - Dropping columns with > 50% missing values
+        - Imputing missing values for numeric and categorical columns
+        - Encoding categorical variables
+        """
+        df = self.raw_df.copy()
+        
+        # Drop columns with > 50% missing values
+        threshold = len(df) * 0.5
+        df = df.dropna(thresh=threshold, axis=1)
+        
+        # Impute missing values
+        for col in df.columns:
+            if df[col].dtype in ['int64', 'float64']:
+                df[col] = df[col].fillna(df[col].median())
+            else:
+                df[col] = df[col].fillna(df[col].mode()[0])
+                
+        # Basic categorical encoding (one-hot) for columns with few unique values
+        cat_cols = df.select_dtypes(include=['object', 'category']).columns
+        df = pd.get_dummies(df, columns=[c for c in cat_cols if df[c].nunique() < 10], drop_first=True)
+        
+        # Drop remaining objects that weren't encoded
+        df = df.select_dtypes(exclude=['object'])
+        
+        self.clean_df = df
+        return self.clean_df
+
+    def select_and_train_model(self, target_column: str, task_type: str = 'auto') -> dict:
+        """
+        Selects and trains a basic model (Classification or Regression).
+        Returns a dictionary report with metrics and feature importances.
+        """
+        if self.clean_df is None:
+            self.auto_clean()
+            
+        if target_column not in self.clean_df.columns:
+            raise ValueError(f"Target column '{target_column}' not found in cleaned data.")
+            
+        X = self.clean_df.drop(columns=[target_column])
+        y = self.clean_df[target_column]
+        
+        # Auto-detect task type if not specified
+        if task_type == 'auto':
+            if y.nunique() < 20 and y.dtype in ['int64', 'bool', 'uint8']:
+                task_type = 'classification'
+            else:
+                task_type = 'regression'
+                
+        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+        
+        if task_type == 'classification':
+            self.model = RandomForestClassifier(random_state=42)
+            self.model.fit(X_train, y_train)
+            preds = self.model.predict(X_test)
+            score = accuracy_score(y_test, preds)
+            metric_name = "Accuracy"
+        else:
+            self.model = RandomForestRegressor(random_state=42)
+            self.model.fit(X_train, y_train)
+            preds = self.model.predict(X_test)
+            score = mean_squared_error(y_test, preds) ** 0.5
+            metric_name = "RMSE"
+            
+        self.report = {
+            "task_type": task_type,
+            "target_column": target_column,
+            metric_name: score,
+            "feature_importances": dict(zip(X.columns, self.model.feature_importances_))
+        }
+        
+        return self.report
+
+    def generate_visualizations(self, target_column: str) -> dict:
+        """
+        Generates standard visualizations and returns a dictionary of matplotlib figure objects.
+        """
+        if self.clean_df is None:
+            self.auto_clean()
+            
+        fig, ax = plt.subplots(figsize=(8, 5))
+        self.clean_df[target_column].hist(bins=20, ax=ax)
+        ax.set_title(f"Distribution of {target_column}")
+        ax.set_xlabel(target_column)
+        ax.set_ylabel("Frequency")
+        
+        self.figures['target_distribution'] = fig
+        
+        # Add feature importance visualization if a model has been trained
+        if self.model and self.report:
+            importances = pd.Series(self.report['feature_importances']).sort_values(ascending=False).head(10)
+            fig2, ax2 = plt.subplots(figsize=(10, 6))
+            importances.plot(kind='bar', ax=ax2)
+            ax2.set_title("Top 10 Feature Importances")
+            ax2.set_ylabel("Importance")
+            plt.tight_layout()
+            self.figures['feature_importance'] = fig2
+            
+        return self.figures
+        
+    def get_openai_insights(self, api_key: str, prompt: str) -> str:
+        """
+        Uses OpenAI to generate insights based on the model report.
+        """
+        if not self.report:
+            raise ValueError("Train a model first to generate insights based on the report.")
+            
+        openai.api_key = api_key
+        
+        system_prompt = "You are a data science expert analyzing machine learning model results."
+        user_prompt = f"Here is the model report:\n{self.report}\n\nUser Question: {prompt}"
+        
+        # Uses the newer OpenAI API format if openai>=1.0.0
+        try:
+            client = openai.OpenAI(api_key=api_key)
+            response = client.chat.completions.create(
+                model="gpt-3.5-turbo",
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": user_prompt}
+                ]
+            )
+            return response.choices[0].message.content
+        except AttributeError:
+            # Fallback for older openai versions
+            response = openai.ChatCompletion.create(
+                model="gpt-3.5-turbo",
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": user_prompt}
+                ]
+            )
+            return response.choices[0].message.content

sol_ai_core-0.1.0/test_engine.py

@@ -0,0 +1,39 @@
+import pandas as pd
+from sklearn.datasets import load_iris
+from sol_core.engine import SolEngine
+
+# 1. Load sample dataset
+print("Loading sample dataset...")
+data = load_iris()
+df = pd.DataFrame(data.data, columns=data.feature_names)
+df['target'] = data.target
+
+# 2. Initialize the engine
+print("Initializing SolEngine...")
+engine = SolEngine(df)
+
+# 3. Clean the data automatically
+print("Running auto_clean()...")
+clean_df = engine.auto_clean()
+print("Cleaned DataFrame shape:", clean_df.shape)
+
+# 4. Train a model automatically (Classification)
+print("\nRunning select_and_train_model()...")
+report = engine.select_and_train_model(target_column="target")
+
+print("\n--- Model Report ---")
+for key, value in report.items():
+    if key == "feature_importances":
+        print(f"{key}:")
+        for feat, imp in list(value.items()):
+            print(f"  - {feat}: {imp:.4f}")
+    else:
+        print(f"{key}: {value}")
+print("--------------------")
+
+# 5. Generate Visualizations 
+print("\nGenerating visualizations...")
+figures = engine.generate_visualizations(target_column="target")
+print("Generated figure objects:", list(figures.keys()))
+
+print("\nCode executed successfully!")

sol_ai_core-0.1.0/tests/test_engine.py

@@ -0,0 +1,72 @@
+import pytest
+import pandas as pd
+import numpy as np
+from sol_core.engine import SolEngine
+
+@pytest.fixture
+def sample_dataframe():
+    """Returns a sample dataframe with missing values and mixed types for testing."""
+    data = {
+        'num_col': [1, 2, np.nan, 4, 5, 6, 7, 8, 9, 10],
+        'cat_col': ['A', 'B', 'A', np.nan, 'C', 'A', 'B', 'C', 'A', 'B'],
+        'mostly_missing': [np.nan] * 6 + [1, 2, 3, 4], # > 50% missing
+        'target': [0, 1, 0, 1, 0, 1, 0, 1, 0, 1]
+    }
+    return pd.DataFrame(data)
+
+def test_engine_initialization(sample_dataframe):
+    engine = SolEngine(sample_dataframe)
+    assert engine.raw_df.equals(sample_dataframe)
+    assert engine.clean_df is None
+    assert engine.model is None
+
+def test_auto_clean(sample_dataframe):
+    engine = SolEngine(sample_dataframe)
+    clean_df = engine.auto_clean()
+    
+    # Check that column 'mostly_missing' is dropped
+    assert 'mostly_missing' not in clean_df.columns
+    
+    # Check that missing values are imputed
+    assert not clean_df.isnull().values.any()
+    
+    # Check that categorical variable is encoded
+    assert 'cat_col' not in clean_df.columns
+    assert any(col.startswith('cat_col_') for col in clean_df.columns)
+    
+def test_select_and_train_model_classification(sample_dataframe):
+    engine = SolEngine(sample_dataframe)
+    engine.auto_clean()
+    
+    # Train classification model
+    report = engine.select_and_train_model(target_column='target')
+    
+    assert report['task_type'] == 'classification'
+    assert 'Accuracy' in report
+    assert 'feature_importances' in report
+    assert engine.model is not None
+
+def test_select_and_train_model_regression():
+    # Generate regression data
+    from sklearn.datasets import make_regression
+    X, y = make_regression(n_samples=100, n_features=3, random_state=42)
+    df = pd.DataFrame(X, columns=['f1', 'f2', 'f3'])
+    df['target'] = y
+    
+    engine = SolEngine(df)
+    report = engine.select_and_train_model(target_column='target')
+    
+    assert report['task_type'] == 'regression'
+    assert 'RMSE' in report
+    assert engine.model is not None
+
+def test_generate_visualizations(sample_dataframe):
+    engine = SolEngine(sample_dataframe)
+    # Train a model first to get feature importance visualization too
+    engine.select_and_train_model(target_column='target')
+    figures = engine.generate_visualizations(target_column='target')
+    
+    assert 'target_distribution' in figures
+    assert 'feature_importance' in figures
+    import matplotlib.pyplot as plt
+    assert isinstance(figures['target_distribution'], plt.Figure)