serverlex 1.0.0__py3-none-any.whl

Pipeline.py

@@ -0,0 +1,251 @@
+import logging
+import pandas as pd
+import numpy as np
+from Clean import Clean
+
+from sklearn.model_selection import cross_val_score, KFold, StratifiedKFold
+from sklearn.linear_model import LogisticRegression, Ridge
+from sklearn.tree import DecisionTreeClassifier, DecisionTreeRegressor
+from sklearn.ensemble import RandomForestClassifier, RandomForestRegressor, GradientBoostingClassifier, GradientBoostingRegressor
+
+logger=logging.getLogger("Pipeline")
+if not logger.handlers:
+    _h=logging.StreamHandler()
+    _h.setFormatter(logging.Formatter("%(asctime)s [%(levelname)s] %(name)s: %(message)s", "%Y-%m-%d %H:%M:%S"))
+    logger.addHandler(_h)
+    logger.setLevel(logging.INFO)
+
+
+class MLPipeline:
+    def __init__(self, data=None):
+        self.data=None
+        self.cleaner=None
+        self.target=None
+        self.feature_columns=[]
+        self.num_fill={}
+        self.cat_fill={}
+        self.scaler_mean={}
+        self.scaler_std={}
+        self.date_col=None
+        self.custom_models={}
+
+        if data is not None:
+            self.load_data(data)
+
+    def load_data(self, data):
+        if isinstance(data, str):
+            self.cleaner=Clean(data)
+            self.cleaner.load()
+            self.data=self.cleaner.data
+        elif isinstance(data, Clean):
+            self.cleaner=data
+            self.data=self.cleaner.data
+        elif isinstance(data, pd.DataFrame):
+            self.cleaner=Clean.__new__(Clean)
+            self.cleaner.data=data.copy()
+            self.cleaner.path=None
+            self.data=data
+
+    # ==========================
+    # 1. FIT (Learn & Save on self)
+    # ==========================
+    def fit(self, df, target=None, encode='onehot', scale='standard', data_time=None, numeric_string_cols=None, **kwargs):
+        try:
+            self.load_data(df)
+            self.target=target.strip().lower() if target else None
+            self.encode=encode
+            self.scale=scale
+            self.numeric_string_cols=[c.strip().lower().replace(' ', '_') for c in (numeric_string_cols or [])]
+
+            logger.info("Fitting pipeline on %d rows (target=%s, encode=%s, scale=%s)", len(self.data), self.target, self.encode, self.scale)
+
+            # 1. Clean the training data using your Clean class
+            self.cleaner.total_clean(data_time=data_time, numeric_string_cols=numeric_string_cols, **kwargs)
+            self.data=self.cleaner.data
+            self.cleaner.seperate()
+
+            # 2. Extract datetime features if provided
+            if data_time:
+                col=data_time[0].strip().lower().replace(' ', '_')
+                if col in self.data.columns:
+                    self.date_col=col
+                    dt=pd.to_datetime(self.data[col], format='mixed', errors='coerce')
+                    self.data[f'{col}_year']=dt.dt.year
+                    self.data[f'{col}_month']=dt.dt.month
+                    self.data[f'{col}_day']=dt.dt.day
+                    self.data[f'{col}_dayofweek']=dt.dt.dayofweek
+                    self.data=self.data.drop(columns=[col])
+
+            self.cleaner.data=self.data
+            self.cleaner.seperate()
+
+            # 3. Memorize missing value fill values directly on self
+            for col in self.cleaner.numerical_columns.columns:
+                if col != self.target:
+                    self.num_fill[col]=self.data[col].mean()
+
+            for col in self.cleaner.categrorical_columns.columns:
+                if col != self.target:
+                    mode_val=self.data[col].mode()
+                    self.cat_fill[col]=mode_val[0] if not mode_val.empty else 'unknown'
+
+            # 4. Encode categoricals to find final feature columns
+            train_X=self.data.copy()
+            if self.target and self.target in train_X.columns:
+                train_X=train_X.drop(columns=[self.target])
+
+            cat_cols=[c for c in self.cleaner.categrorical_columns.columns if c != self.target and c in train_X.columns]
+            if self.encode=='onehot' and cat_cols:
+                train_X=pd.get_dummies(train_X, columns=cat_cols, drop_first=True, dtype=int)
+            elif self.encode=='label' and cat_cols:
+                for col in cat_cols:
+                    train_X[col]=train_X[col].astype('category').cat.codes
+
+            # Save exact list of final columns for future test data
+            self.feature_columns=train_X.columns.tolist()
+
+            # 5. Memorize scaling numbers on self
+            if self.scale=='standard':
+                for col in self.cleaner.numerical_columns.columns:
+                    if col in self.feature_columns:
+                        self.scaler_mean[col]=train_X[col].mean()
+                        std_val=train_X[col].std()
+                        self.scaler_std[col]=std_val if std_val != 0 else 1.0
+
+            logger.info("Fit complete. Feature count: %d", len(self.feature_columns))
+            return self
+        except Exception as e:
+            logger.error("Error during fit: %s", e)
+            return self
+
+    # ==========================
+    # 2. TRANSFORM (Uses self variables)
+    # ==========================
+    def transform(self, df):
+        try:
+            out=df.copy()
+
+            # 1. Clean column names
+            out.columns=out.columns.str.strip().str.lower().str.replace(' ', '_').str.replace(r'[^\w_]', '', regex=True)
+
+            # Clean numeric string columns using saved self.numeric_string_cols
+            if hasattr(self, 'numeric_string_cols'):
+                for col in self.numeric_string_cols:
+                    if col in out.columns:
+                        cleaned=out[col].astype(str).str.replace(r'[\$,]', '', regex=True)
+                        out[col]=pd.to_numeric(cleaned, errors='coerce')
+
+            # 2. Extract datetime features using saved date_col
+            if self.date_col and self.date_col in out.columns:
+                dt=pd.to_datetime(out[self.date_col], format='mixed', errors='coerce')
+                out[f'{self.date_col}_year']=dt.dt.year
+                out[f'{self.date_col}_month']=dt.dt.month
+                out[f'{self.date_col}_day']=dt.dt.day
+                out[f'{self.date_col}_dayofweek']=dt.dt.dayofweek
+                out=out.drop(columns=[self.date_col])
+
+            # 3. Fill missing using memorized self.num_fill and self.cat_fill
+            for col, val in self.num_fill.items():
+                if col in out.columns:
+                    out[col]=out[col].fillna(val)
+
+            for col, val in self.cat_fill.items():
+                if col in out.columns:
+                    out[col]=out[col].astype(str).str.lower().str.replace(' ', '')
+                    out[col]=out[col].fillna(val)
+
+            # 4. Check target
+            has_target=self.target and self.target in out.columns
+            target_series=out[self.target] if has_target else None
+
+            # 5. Encode categoricals
+            cat_cols=[c for c in self.cat_fill.keys() if c in out.columns]
+            if self.encode=='onehot' and cat_cols:
+                out=pd.get_dummies(out, columns=cat_cols, drop_first=True, dtype=int)
+            elif self.encode=='label' and cat_cols:
+                for col in cat_cols:
+                    out[col]=out[col].astype('category').cat.codes
+
+            # 6. Reindex columns so test columns match self.feature_columns exactly
+            X=out.reindex(columns=self.feature_columns, fill_value=0)
+
+            # 7. Scale using memorized self.scaler_mean and self.scaler_std
+            if self.scale=='standard':
+                for col in self.scaler_mean.keys():
+                    if col in X.columns:
+                        X[col]=(X[col] - self.scaler_mean[col]) / self.scaler_std[col]
+
+            if has_target:
+                return X, target_series
+            return X
+        except Exception as e:
+            logger.error("Error during transform: %s", e)
+            return df
+
+    def fit_transform(self, df, **kwargs):
+        self.fit(df, **kwargs)
+        return self.transform(df)
+
+    # ==========================
+    # 3. Custom Models & Evaluation
+    # ==========================
+    def add_model(self, name, model):
+        self.custom_models[name]=model
+        logger.info("Registered custom model '%s'", name)
+        return self
+
+    def evaluate_baseline_models(self, X, y, cv=5):
+        try:
+            if not isinstance(y, pd.Series):
+                y=pd.Series(y)
+
+            is_classification=y.dtype=='object' or str(y.dtype).startswith('cat') or y.nunique() <= 20
+            task="Classification" if is_classification else "Regression"
+
+            results=[]
+
+            if is_classification:
+                kf=StratifiedKFold(n_splits=cv, shuffle=True, random_state=42)
+                models={
+                    "Logistic Regression": LogisticRegression(max_iter=1000),
+                    "Decision Tree": DecisionTreeClassifier(random_state=42),
+                    "Random Forest": RandomForestClassifier(n_estimators=100, random_state=42),
+                    "Gradient Boosting": GradientBoostingClassifier(random_state=42)
+                }
+                models.update(self.custom_models)
+                logger.info("Evaluating %d baseline models (task=%s, cv=%d)", len(models), task, cv)
+
+                for name, model in models.items():
+                    try:
+                        acc=cross_val_score(model, X, y, cv=kf, scoring="accuracy")
+                        f1=cross_val_score(model, X, y, cv=kf, scoring="f1_weighted")
+                        results.append({"Model": name, "Accuracy": round(acc.mean(), 4), "F1": round(f1.mean(), 4)})
+                    except Exception as e:
+                        results.append({"Model": name, "Accuracy": None, "F1": str(e)})
+
+                leaderboard=pd.DataFrame(results).sort_values(by="Accuracy", ascending=False)
+            else:
+                kf=KFold(n_splits=cv, shuffle=True, random_state=42)
+                models={
+                    "Ridge Regression": Ridge(),
+                    "Decision Tree": DecisionTreeRegressor(random_state=42),
+                    "Random Forest": RandomForestRegressor(n_estimators=100, random_state=42),
+                    "Gradient Boosting": GradientBoostingRegressor(random_state=42)
+                }
+                models.update(self.custom_models)
+                logger.info("Evaluating %d baseline models (task=%s, cv=%d)", len(models), task, cv)
+
+                for name, model in models.items():
+                    try:
+                        r2=cross_val_score(model, X, y, cv=kf, scoring="r2")
+                        rmse=cross_val_score(model, X, y, cv=kf, scoring="neg_root_mean_squared_error")
+                        results.append({"Model": name, "R2": round(r2.mean(), 4), "RMSE": round(-rmse.mean(), 4)})
+                    except Exception as e:
+                        results.append({"Model": name, "R2": None, "RMSE": str(e)})
+
+                leaderboard=pd.DataFrame(results).sort_values(by="R2", ascending=False)
+
+            logger.info("Baseline leaderboard:\n%s", leaderboard.to_string(index=False))
+            return leaderboard
+        except Exception as e:
+            logger.error("Error in evaluate_baseline_models: %s", e)

Visualization.py

@@ -0,0 +1,362 @@
+import logging
+import matplotlib.pyplot as plt
+import pandas as pd
+import numpy as np
+from Clean import Clean
+
+logger=logging.getLogger("Visualization")
+if not logger.handlers:
+    _h=logging.StreamHandler()
+    _h.setFormatter(logging.Formatter("%(asctime)s [%(levelname)s] %(name)s: %(message)s", "%Y-%m-%d %H:%M:%S"))
+    logger.addHandler(_h)
+    logger.setLevel(logging.INFO)
+
+
+class Visualize:
+    def __init__(self, data=None):
+        """
+        data can be:
+        - A CSV file path (str)
+        - An instance of Clean
+        - A pandas DataFrame
+        - None (data can be set or loaded later)
+        """
+        self.data = None
+        self.cleaner = None
+        if data is not None:
+            self.set_data(data)
+
+    def set_data(self, data):
+        """Sets or updates the active dataset."""
+        if isinstance(data, str):
+            self.cleaner = Clean(data)
+            self.cleaner.load()
+            self.data = self.cleaner.data
+        elif isinstance(data, Clean):
+            self.cleaner = data
+            if not hasattr(self.cleaner, "data") or self.cleaner.data is None:
+                self.cleaner.load()
+            self.data = self.cleaner.data
+        elif isinstance(data, pd.DataFrame):
+            self.cleaner = Clean.__new__(Clean)
+            self.cleaner.data = data.copy()
+            self.cleaner.path = None
+            self.data = data
+
+    def _sync(self):
+        """Syncs self.data from self.cleaner if cleaner modified the dataframe."""
+        if self.cleaner is not None and hasattr(self.cleaner, "data") and self.cleaner.data is not None:
+            self.data = self.cleaner.data
+
+    # ==========================
+    # 1. Individual Plot Methods
+    # ==========================
+
+    def plot_missing(self, title="Missing Values per Column"):
+        """Plots a bar chart showing the count of missing values for columns with NaNs."""
+        self._sync()
+        try:
+            if self.data is None:
+                print("No data available to plot.")
+                return
+
+            missing = self.data.isnull().sum()
+            missing = missing[missing > 0]
+            if missing.empty:
+                print("No missing values found in dataset.")
+                return
+
+            fig, ax = plt.subplots(figsize=(8, 4))
+            missing.plot(kind="bar", color="salmon", edgecolor="black", ax=ax)
+            ax.set_title(title, fontsize=12, fontweight="bold")
+            ax.set_ylabel("Count of NaNs")
+            ax.set_xlabel("Columns")
+            plt.xticks(rotation=45, ha="right")
+            plt.tight_layout()
+            plt.show()
+        except Exception as e:
+            print(e)
+
+    def plot_distribution(self, column=None, bins=20):
+        """Plots histograms for one or all numerical columns."""
+        self._sync()
+        try:
+            if self.data is None:
+                print("No data available to plot.")
+                return
+
+            num_cols = self.data.select_dtypes(include="number").columns
+            if len(num_cols) == 0:
+                print("No numerical columns available.")
+                return
+
+            cols = [column] if column else num_cols
+            n_cols = len(cols)
+            fig, axes = plt.subplots(1, n_cols, figsize=(4 * n_cols, 4), squeeze=False)
+            for i, col in enumerate(cols):
+                if col in self.data.columns:
+                    axes[0, i].hist(self.data[col].dropna(), bins=bins, color="skyblue", edgecolor="black")
+                    axes[0, i].set_title(f"Dist: {col}")
+                    axes[0, i].set_xlabel(col)
+                    axes[0, i].set_ylabel("Frequency")
+            plt.tight_layout()
+            plt.show()
+        except Exception as e:
+            print(e)
+
+    def plot_box(self, columns=None, title="Outlier Detection (Box Plot)"):
+        """Plots box plots for numeric columns to visualize outliers."""
+        self._sync()
+        try:
+            if self.data is None:
+                print("No data available to plot.")
+                return
+
+            num_df = self.data.select_dtypes(include="number")
+            if num_df.empty:
+                print("No numerical columns for box plot.")
+                return
+
+            if columns:
+                valid_cols = [c for c in columns if c in num_df.columns]
+                num_df = num_df[valid_cols]
+
+            fig, ax = plt.subplots(figsize=(max(6, len(num_df.columns) * 1.5), 5))
+            num_df.boxplot(ax=ax, patch_artist=True, boxprops=dict(facecolor="lightblue"))
+            ax.set_title(title, fontsize=12, fontweight="bold")
+            plt.xticks(rotation=45, ha="right")
+            plt.tight_layout()
+            plt.show()
+        except Exception as e:
+            print(e)
+
+    def plot_categorical(self, column=None, top_n=10, title=None):
+        """Plots horizontal bar chart of top N categories."""
+        self._sync()
+        try:
+            if self.data is None:
+                print("No data available to plot.")
+                return
+
+            cat_cols = self.data.select_dtypes(include=["object", "category"]).columns
+            if len(cat_cols) == 0:
+                print("No categorical columns available.")
+                return
+
+            col = column if column else cat_cols[0]
+            if col not in self.data.columns:
+                print(f"Column '{col}' not found.")
+                return
+
+            counts = self.data[col].value_counts().head(top_n)
+            fig, ax = plt.subplots(figsize=(8, 4))
+            counts.plot(kind="barh", color="mediumaquamarine", edgecolor="black", ax=ax)
+            ax.invert_yaxis()
+            ax.set_title(title or f"Top {top_n} Categories in '{col}'", fontsize=12, fontweight="bold")
+            ax.set_xlabel("Count")
+            plt.tight_layout()
+            plt.show()
+        except Exception as e:
+            print(e)
+
+    def plot_correlation(self, title="Correlation Matrix Heatmap"):
+        """Plots a correlation heatmap for numerical features using matplotlib."""
+        self._sync()
+        try:
+            if self.data is None:
+                print("No data available to plot.")
+                return
+
+            num_df = self.data.select_dtypes(include="number")
+            if num_df.shape[1] < 2:
+                print("Need at least 2 numerical columns for correlation plot.")
+                return
+
+            corr = num_df.corr()
+            fig, ax = plt.subplots(figsize=(max(6, len(corr) * 1.2), max(5, len(corr) * 1.0)))
+            cax = ax.imshow(corr, cmap="coolwarm", vmin=-1, vmax=1)
+            fig.colorbar(cax, ax=ax)
+
+            ax.set_xticks(range(len(corr.columns)))
+            ax.set_yticks(range(len(corr.columns)))
+            ax.set_xticklabels(corr.columns, rotation=45, ha="right")
+            ax.set_yticklabels(corr.columns)
+
+            # Annotate correlation values in cells
+            for i in range(len(corr)):
+                for j in range(len(corr.columns)):
+                    val = corr.iloc[i, j]
+                    ax.text(j, i, f"{val:.2f}", ha="center", va="center", color="black" if abs(val) < 0.7 else "white", fontsize=9)
+
+            ax.set_title(title, fontsize=12, fontweight="bold")
+            plt.tight_layout()
+            plt.show()
+        except Exception as e:
+            print(e)
+
+    def plot_scatter(self, x, y, title=None):
+        """Plots a scatter plot between two numerical columns."""
+        self._sync()
+        try:
+            if self.data is None:
+                print("No data available to plot.")
+                return
+
+            if x not in self.data.columns or y not in self.data.columns:
+                print(f"One or both columns ({x}, {y}) not in DataFrame.")
+                return
+
+            fig, ax = plt.subplots(figsize=(6, 4))
+            ax.scatter(self.data[x], self.data[y], color="steelblue", alpha=0.7, edgecolors="k")
+            ax.set_title(title or f"{x} vs {y}", fontsize=12, fontweight="bold")
+            ax.set_xlabel(x)
+            ax.set_ylabel(y)
+            ax.grid(True, linestyle="--", alpha=0.5)
+            plt.tight_layout()
+            plt.show()
+        except Exception as e:
+            print(e)
+
+    # ==============================================================
+    # 2. Live Interactive Cleaning Pipeline with plt.ion()
+    # ==============================================================
+
+    def live_clean(
+        self,
+        cleaner=None,
+        data_time=None,
+        numeric_string_cols=None,
+        missing_param="m",
+        outlier_method="IQR",
+        outlier_param="m",
+        corr_target=None,
+        corr_threshold=0.1,
+        pause_time=1.5
+    ):
+        """
+        Runs the cleaning pipeline step-by-step with plt.ion() (interactive mode),
+        updating live plots at each stage to show before & after transformations.
+        """
+        if cleaner is not None:
+            self.cleaner = cleaner
+        elif self.cleaner is None:
+            print("No cleaner instance provided.")
+            return
+
+        # Enable interactive plotting
+        plt.ion()
+        fig = plt.figure(figsize=(10, 6))
+        logger.info("Initializing live visual cleaning session")
+
+        try:
+            # 1. Load & Deduplicate
+            self.cleaner.load()
+            self.cleaner.clean_column_names()
+            self.cleaner.delete_duplicates()
+            self._sync()
+
+            # Step 1: Missing values BEFORE imputation
+            plt.clf()
+            ax = fig.add_subplot(111)
+            missing_before = self.data.isnull().sum()
+            missing_before = missing_before[missing_before > 0]
+            if not missing_before.empty:
+                missing_before.plot(kind="bar", color="crimson", edgecolor="black", ax=ax)
+                ax.set_title("Step 1: Missing Values (BEFORE Imputation)", fontsize=13, fontweight="bold")
+                ax.set_ylabel("Count of NaNs")
+                plt.xticks(rotation=45, ha="right")
+                plt.tight_layout()
+                plt.draw()
+                plt.pause(pause_time)
+
+            # Step 2: Impute Missing Values
+            if numeric_string_cols:
+                self.cleaner.clean_numeric_strings(numeric_string_cols)
+            self.cleaner.Clean_string(data_time=data_time)
+            self.cleaner.fill_missing(param=missing_param)
+            self.cleaner.fill_categorical_missing()
+            self._sync()
+
+            plt.clf()
+            ax = fig.add_subplot(111)
+            missing_after = self.data.isnull().sum()
+            missing_after.plot(kind="bar", color="mediumseagreen", edgecolor="black", ax=ax)
+            ax.set_title("Step 2: Missing Values (AFTER Imputation - All Filled)", fontsize=13, fontweight="bold")
+            ax.set_ylabel("Count of NaNs")
+            plt.xticks(rotation=45, ha="right")
+            plt.tight_layout()
+            plt.draw()
+            plt.pause(pause_time)
+
+            # Step 3: Outliers BEFORE Handling
+            num_cols = self.data.select_dtypes(include="number").columns.tolist()
+            if num_cols:
+                plt.clf()
+                ax = fig.add_subplot(111)
+                self.data[num_cols].boxplot(ax=ax, patch_artist=True, boxprops=dict(facecolor="orange"))
+                ax.set_title(f"Step 3: Outliers (BEFORE {outlier_method})", fontsize=13, fontweight="bold")
+                plt.xticks(rotation=45, ha="right")
+                plt.tight_layout()
+                plt.draw()
+                plt.pause(pause_time)
+
+                # Execute outlier handling
+                if outlier_method == "IQR":
+                    self.cleaner.outliers_IQR(param=outlier_param)
+                else:
+                    self.cleaner.outliers_Z(param=outlier_param)
+                self._sync()
+
+                # Step 4: Outliers AFTER Handling
+                plt.clf()
+                ax = fig.add_subplot(111)
+                self.data[num_cols].boxplot(ax=ax, patch_artist=True, boxprops=dict(facecolor="lightgreen"))
+                ax.set_title(f"Step 4: Outliers (AFTER {outlier_method} param='{outlier_param}')", fontsize=13, fontweight="bold")
+                plt.xticks(rotation=45, ha="right")
+                plt.tight_layout()
+                plt.draw()
+                plt.pause(pause_time)
+
+            # Step 5: Correlation Heatmap BEFORE low_corr
+            num_df = self.data.select_dtypes(include="number")
+            if num_df.shape[1] >= 2:
+                plt.clf()
+                ax = fig.add_subplot(111)
+                corr = num_df.corr()
+                cax = ax.imshow(corr, cmap="coolwarm", vmin=-1, vmax=1)
+                fig.colorbar(cax, ax=ax)
+                ax.set_xticks(range(len(corr.columns)))
+                ax.set_yticks(range(len(corr.columns)))
+                ax.set_xticklabels(corr.columns, rotation=45, ha="right")
+                ax.set_yticklabels(corr.columns)
+                ax.set_title("Step 5: Correlation Matrix (BEFORE low_corr filter)", fontsize=13, fontweight="bold")
+                plt.tight_layout()
+                plt.draw()
+                plt.pause(pause_time)
+
+                # Execute low_corr
+                if corr_threshold is not None:
+                    self.cleaner.low_corr(target=corr_target, threshold=corr_threshold)
+                    self._sync()
+
+                    # Step 6: Correlation Heatmap AFTER low_corr
+                    plt.clf()
+                    ax = fig.add_subplot(111)
+                    corr_after = self.data.select_dtypes(include="number").corr()
+                    cax2 = ax.imshow(corr_after, cmap="coolwarm", vmin=-1, vmax=1)
+                    fig.colorbar(cax2, ax=ax)
+                    ax.set_xticks(range(len(corr_after.columns)))
+                    ax.set_yticks(range(len(corr_after.columns)))
+                    ax.set_xticklabels(corr_after.columns, rotation=45, ha="right")
+                    ax.set_yticklabels(corr_after.columns)
+                    ax.set_title("Step 6: Correlation Matrix (AFTER low_corr filter)", fontsize=13, fontweight="bold")
+                    plt.tight_layout()
+                    plt.draw()
+                    plt.pause(pause_time)
+
+            logger.info("Live visual cleaning session completed")
+        except Exception as e:
+            logger.error("Error in live_clean: %s", e)
+        finally:
+            plt.ioff()
+            plt.show()

serverlex/__init__.py

@@ -0,0 +1,34 @@
+import sys
+import os
+
+_parent_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+if _parent_dir not in sys.path:
+    sys.path.insert(0, _parent_dir)
+
+from Clean import Clean
+from Visualization import Visualize
+from DataCheck import DataGuard
+from Pipeline import MLPipeline
+from FeatureSelector import FeatureSelector
+from ModelHyperparameter import ModelHyperparameter
+from EnsembleBuilder import EnsembleBuilder
+from Evaluation import ModelEvaluator
+from Explainability import ModelExplainer
+from ModelDeployer import ModelDeployer
+from DriftDetector import DriftDetector
+
+__all__ = [
+    "Clean",
+    "Visualize",
+    "DataGuard",
+    "MLPipeline",
+    "FeatureSelector",
+    "ModelHyperparameter",
+    "EnsembleBuilder",
+    "ModelEvaluator",
+    "ModelExplainer",
+    "ModelDeployer",
+    "DriftDetector"
+]
+
+__version__ = "1.0.0"