pythonlabtools 2.0.0__py3-none-any.whl

pythonlabtools/__init__.py

@@ -0,0 +1,39 @@
+__version__ = "2.0.0"
+
+# Core tools
+from .numpy_tools import (
+    create_range_array,
+    reshape_array,
+    transpose_array,
+    array_sums,
+    even_numbers,
+    center_slice,
+    reverse_array,
+    flatten_array,
+)
+
+from .pandas_tools import (
+    series_to_dataframe,
+    add_pass_fail,
+    passed_students,
+    average_by_group,
+    highest_salary_employee,
+    concat_rows,
+    concat_columns,
+    merge_dataframes,
+    value_counts_all,
+    group_age_statistics,
+)
+
+# Database tools
+from .database import (
+    connect_sqlite,
+    create_table,
+    insert_student,
+    select_students,
+    update_student,
+    delete_student,
+)
+
+# Code viewer
+from .code_viewer import show_code

pythonlabtools/association.py

@@ -0,0 +1,98 @@
+"""Small dependency-light association-rule helpers."""
+
+from collections import Counter
+from itertools import combinations
+import pandas as pd
+
+
+def item_counts(transactions):
+    """Count individual items across transactions."""
+    counts = Counter()
+
+    for transaction in transactions:
+        for item in transaction:
+            counts[item] += 1
+
+    return counts
+
+
+def frequent_items(transactions, min_count=2):
+    """Return items meeting the minimum occurrence count."""
+    counts = item_counts(transactions)
+
+    return {
+        item: count
+        for item, count in counts.items()
+        if count >= min_count
+    }
+
+
+def support(transactions, itemset):
+    """Return support of an itemset."""
+    itemset = set(itemset)
+    count = 0
+
+    for transaction in transactions:
+        if itemset.issubset(set(transaction)):
+            count += 1
+
+    return count / len(transactions)
+
+
+def confidence(transactions, A, B):
+    """Return confidence for A -> B."""
+    return support(transactions, list(A) + list(B)) / support(
+        transactions, A
+    )
+
+
+def lift(transactions, A, B):
+    """Return lift for A -> B."""
+    return confidence(transactions, A, B) / support(
+        transactions, B
+    )
+
+
+def generate_pair_rules(transactions, min_support=0.1):
+    """Generate two-item directional rules."""
+    items = list(item_counts(transactions).keys())
+    rules = []
+
+    for A, B in combinations(items, 2):
+        pair_support = support(
+            transactions,
+            [A, B]
+        )
+
+        if pair_support >= min_support:
+            rules.append({
+                "Rule": f"{A} -> {B}",
+                "Support": pair_support,
+                "Confidence": confidence(
+                    transactions, [A], [B]
+                ),
+                "Lift": lift(
+                    transactions, [A], [B]
+                ),
+            })
+
+            rules.append({
+                "Rule": f"{B} -> {A}",
+                "Support": pair_support,
+                "Confidence": confidence(
+                    transactions, [B], [A]
+                ),
+                "Lift": lift(
+                    transactions, [B], [A]
+                ),
+            })
+
+    return pd.DataFrame(rules)
+
+
+def top_rules_by_lift(rules_df, n=5):
+    """Return top n rules sorted by lift."""
+    return rules_df.sort_values(
+        "Lift",
+        ascending=False
+    ).head(n)

pythonlabtools/classification.py

@@ -0,0 +1,92 @@
+"""Classification helpers for Q50-style lab programs."""
+
+import pandas as pd
+from sklearn.tree import DecisionTreeClassifier
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.linear_model import LogisticRegression
+from sklearn.metrics import (
+    accuracy_score,
+    recall_score,
+    confusion_matrix,
+)
+
+
+def train_classification_models(
+    X_train,
+    X_test,
+    y_train,
+    y_test,
+    scaled_X_train=None,
+    scaled_X_test=None
+):
+    """
+    Train Decision Tree, Random Forest and Logistic Regression.
+
+    Logistic Regression uses scaled data if supplied.
+    """
+    dt = DecisionTreeClassifier(random_state=42)
+    rf = RandomForestClassifier(
+        n_estimators=100,
+        random_state=42
+    )
+
+    dt.fit(X_train, y_train)
+    rf.fit(X_train, y_train)
+
+    if scaled_X_train is None:
+        scaled_X_train = X_train
+    if scaled_X_test is None:
+        scaled_X_test = X_test
+
+    lr = LogisticRegression(max_iter=5000)
+    lr.fit(scaled_X_train, y_train)
+
+    models = {
+        "Decision Tree": dt,
+        "Random Forest": rf,
+        "Logistic Regression": lr,
+    }
+
+    predictions = {
+        "Decision Tree": dt.predict(X_test),
+        "Random Forest": rf.predict(X_test),
+        "Logistic Regression": lr.predict(scaled_X_test),
+    }
+
+    return models, predictions
+
+
+def evaluate_classification(y_test, predictions):
+    """Return accuracy, recall and confusion matrix for each model."""
+    results = {}
+
+    for name, pred in predictions.items():
+        results[name] = {
+            "Accuracy": accuracy_score(y_test, pred),
+            "Recall": recall_score(y_test, pred),
+            "Confusion Matrix": confusion_matrix(y_test, pred),
+        }
+
+    return results
+
+
+def confusion_values(y_test, prediction):
+    """Return TN, FP, FN, TP for binary classification."""
+    cm = confusion_matrix(y_test, prediction)
+    return tuple(cm.ravel())
+
+
+def top_random_forest_features(model, feature_names, n=10):
+    """Return top n features by Random Forest importance."""
+    importance = pd.Series(
+        model.feature_importances_,
+        index=feature_names
+    )
+    return importance.sort_values(
+        ascending=False
+    ).head(n)
+
+
+def predict_new_sample(model, sample):
+    """Predict one or more new samples."""
+    return model.predict(sample)

pythonlabtools/clustering.py

@@ -0,0 +1,60 @@
+"""K-Means and PCA helpers for Q51-style lab programs."""
+
+import matplotlib.pyplot as plt
+from sklearn.cluster import KMeans
+from sklearn.decomposition import PCA
+
+
+def kmeans_models(X, ks=(2, 3, 4), random_state=42):
+    """Run K-Means for several k values."""
+    models = {}
+    labels = {}
+
+    for k in ks:
+        model = KMeans(
+            n_clusters=k,
+            random_state=random_state,
+            n_init=10
+        )
+        labels[k] = model.fit_predict(X)
+        models[k] = model
+
+    return models, labels
+
+
+def elbow_method(X, k_range=range(2, 11), random_state=42):
+    """Return k values and K-Means inertia values."""
+    ks = list(k_range)
+    inertias = []
+
+    for k in ks:
+        model = KMeans(
+            n_clusters=k,
+            random_state=random_state,
+            n_init=10
+        )
+        model.fit(X)
+        inertias.append(model.inertia_)
+
+    return ks, inertias
+
+
+def pca_2d(X):
+    """Reduce features to two PCA components."""
+    pca = PCA(n_components=2)
+    return pca.fit_transform(X), pca
+
+
+def plot_clusters(X_pca, labels, title="K-Means Clusters"):
+    """Plot 2D PCA data colored by cluster label."""
+    plt.figure(figsize=(8, 5))
+    plt.scatter(
+        X_pca[:, 0],
+        X_pca[:, 1],
+        c=labels
+    )
+    plt.xlabel("Principal Component 1")
+    plt.ylabel("Principal Component 2")
+    plt.title(title)
+    plt.tight_layout()
+    plt.show()

pythonlabtools/code_viewer.py

@@ -0,0 +1,305 @@
+import inspect
+import importlib
+import pythonlabtools
+
+
+# Functions that can be displayed directly
+FUNCTION_MODULES = {
+    # NumPy
+    "create_range_array": "numpy_tools",
+    "reshape_array": "numpy_tools",
+    "transpose_array": "numpy_tools",
+    "array_sums": "numpy_tools",
+    "even_numbers": "numpy_tools",
+    "center_slice": "numpy_tools",
+    "reverse_array": "numpy_tools",
+    "flatten_array": "numpy_tools",
+
+    # Pandas
+    "series_to_dataframe": "pandas_tools",
+    "add_pass_fail": "pandas_tools",
+    "passed_students": "pandas_tools",
+    "average_by_group": "pandas_tools",
+    "highest_salary_employee": "pandas_tools",
+    "concat_rows": "pandas_tools",
+    "concat_columns": "pandas_tools",
+    "merge_dataframes": "pandas_tools",
+    "value_counts_all": "pandas_tools",
+    "group_age_statistics": "pandas_tools",
+
+    # Preprocessing
+    "show_missing": "preprocessing",
+    "drop_missing": "preprocessing",
+    "fill_missing_mean": "preprocessing",
+    "fill_missing_median": "preprocessing",
+    "fill_missing_mode": "preprocessing",
+    "convert_numeric": "preprocessing",
+    "remove_duplicates": "preprocessing",
+    "replace_invalid": "preprocessing",
+    "encode_categorical": "preprocessing",
+    "scale_features": "preprocessing",
+    "train_test_scale": "preprocessing",
+    "preprocess_basic": "preprocessing",
+
+    # Plotting
+    "line_plot": "plotting",
+    "bar_plot": "plotting",
+    "scatter_plot": "plotting",
+    "histogram": "plotting",
+    "multiple_plots": "plotting",
+    "correlation_heatmap": "plotting",
+    "box_plot": "plotting",
+
+    # Regression
+    "train_regression_models": "regression",
+    "evaluate_regression": "regression",
+
+    # Classification
+    "train_classification_models": "classification",
+    "evaluate_classification": "classification",
+    "confusion_values": "classification",
+    "top_random_forest_features": "classification",
+    "predict_new_sample": "classification",
+
+    # Clustering
+    "kmeans_models": "clustering",
+    "elbow_method": "clustering",
+    "pca_2d": "clustering",
+    "plot_clusters": "clustering",
+
+    # Association
+    "item_counts": "association",
+    "frequent_items": "association",
+    "support": "association",
+    "confidence": "association",
+    "lift": "association",
+    "generate_pair_rules": "association",
+    "top_rules_by_lift": "association",
+
+    # Database
+    "connect_sqlite": "database",
+    "create_table": "database",
+    "insert_student": "database",
+    "select_students": "database",
+    "update_student": "database",
+    "delete_student": "database",
+}
+
+
+MODULES = {
+    "numpy": "numpy_tools",
+    "pandas": "pandas_tools",
+    "preprocessing": "preprocessing",
+    "plotting": "plotting",
+    "regression": "regression",
+    "classification": "classification",
+    "clustering": "clustering",
+    "association": "association",
+    "database": "database",
+}
+
+
+QUESTION_FILES = {
+    "q49": "examples.q49_regression_template",
+    "q50": "examples.q50_classification_template",
+    "q51": "examples.q51_clustering_template",
+    "q52": "examples.q52_association_template",
+    "q30": "examples.q30_sqlite_template",
+}
+
+
+def show_code(name):
+    """
+    Display the source code of a pythonlabtools function,
+    module, or exam question template.
+
+    Examples:
+        show_code("fill_missing_mean")
+        show_code("preprocessing")
+        show_code("q49")
+    """
+
+    name = name.lower().strip()
+
+    # --------------------------------------------------
+    # 1. Show a specific function
+    # --------------------------------------------------
+    if name in FUNCTION_MODULES:
+
+        module_name = FUNCTION_MODULES[name]
+
+        module = importlib.import_module(
+            f"pythonlabtools.{module_name}"
+        )
+
+        function = getattr(module, name)
+
+        print("=" * 70)
+        print(f"CODE: {name}")
+        print("=" * 70)
+
+        print(inspect.getsource(function))
+
+        return
+
+    # --------------------------------------------------
+    # 2. Show an entire module
+    # --------------------------------------------------
+    if name in MODULES:
+
+        module_name = MODULES[name]
+
+        module = importlib.import_module(
+            f"pythonlabtools.{module_name}"
+        )
+
+        print("=" * 70)
+        print(f"MODULE: {module_name}")
+        print("=" * 70)
+
+        print(inspect.getsource(module))
+
+        return
+
+    # --------------------------------------------------
+    # 3. Show an exam question template
+    # --------------------------------------------------
+    if name in QUESTION_FILES:
+
+        module_name = QUESTION_FILES[name]
+
+        module = importlib.import_module(module_name)
+
+        print("=" * 70)
+        print(f"EXAM TEMPLATE: {name.upper()}")
+        print("=" * 70)
+
+        print(inspect.getsource(module))
+
+        return
+
+    # --------------------------------------------------
+    # 4. Help
+    # --------------------------------------------------
+    if name in ["help", "list", "all"]:
+
+        print("""
+============================================================
+PYTHONLABTOOLS CODE VIEWER
+============================================================
+
+NUMPY
+-----
+create_range_array
+reshape_array
+transpose_array
+array_sums
+even_numbers
+center_slice
+reverse_array
+flatten_array
+
+PANDAS
+------
+series_to_dataframe
+add_pass_fail
+passed_students
+average_by_group
+highest_salary_employee
+concat_rows
+concat_columns
+merge_dataframes
+value_counts_all
+group_age_statistics
+
+PREPROCESSING
+-------------
+show_missing
+drop_missing
+fill_missing_mean
+fill_missing_median
+fill_missing_mode
+convert_numeric
+remove_duplicates
+replace_invalid
+encode_categorical
+scale_features
+train_test_scale
+preprocess_basic
+
+PLOTTING
+--------
+line_plot
+bar_plot
+scatter_plot
+histogram
+multiple_plots
+correlation_heatmap
+box_plot
+
+MACHINE LEARNING
+----------------
+train_regression_models
+evaluate_regression
+train_classification_models
+evaluate_classification
+confusion_values
+top_random_forest_features
+predict_new_sample
+
+CLUSTERING
+----------
+kmeans_models
+elbow_method
+pca_2d
+plot_clusters
+
+ASSOCIATION RULES
+-----------------
+item_counts
+frequent_items
+support
+confidence
+lift
+generate_pair_rules
+top_rules_by_lift
+
+DATABASE
+--------
+connect_sqlite
+create_table
+insert_student
+select_students
+update_student
+delete_student
+
+EXAM TEMPLATES
+--------------
+q30
+q49
+q50
+q51
+q52
+
+EXAMPLES
+--------
+show_code("fill_missing_mean")
+show_code("preprocessing")
+show_code("q49")
+show_code("help")
+
+============================================================
+""")
+
+        return
+
+    # --------------------------------------------------
+    # 5. Invalid name
+    # --------------------------------------------------
+
+    print(f"'{name}' was not found.")
+
+    print("\nType:")
+    print('    show_code("help")')
+
+    print("to see the available functions.")

pythonlabtools/database.py

@@ -0,0 +1,49 @@
+"""Simple SQLite helpers for the database portion of the lab."""
+
+import sqlite3
+
+
+def connect_sqlite(path="students.db"):
+    return sqlite3.connect(path)
+
+
+def create_table(conn):
+    conn.execute("""
+        CREATE TABLE IF NOT EXISTS students (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            name TEXT,
+            marks INTEGER
+        )
+    """)
+    conn.commit()
+
+
+def insert_student(conn, name, marks):
+    conn.execute(
+        "INSERT INTO students (name, marks) VALUES (?, ?)",
+        (name, marks)
+    )
+    conn.commit()
+
+
+def select_students(conn):
+    cursor = conn.execute(
+        "SELECT * FROM students"
+    )
+    return cursor.fetchall()
+
+
+def update_student(conn, name, new_marks):
+    conn.execute(
+        "UPDATE students SET marks=? WHERE name=?",
+        (new_marks, name)
+    )
+    conn.commit()
+
+
+def delete_student(conn, name):
+    conn.execute(
+        "DELETE FROM students WHERE name=?",
+        (name,)
+    )
+    conn.commit()

pythonlabtools/numpy_tools.py

@@ -0,0 +1,51 @@
+"""NumPy helpers matching common lab questions."""
+
+import numpy as np
+
+
+def create_range_array(start=1, stop=20):
+    """Create a 1-D array from start through stop, inclusive."""
+    return np.arange(start, stop + 1)
+
+
+def reshape_array(arr, rows, columns):
+    """Reshape an array into rows x columns."""
+    return np.asarray(arr).reshape(rows, columns)
+
+
+def transpose_array(arr):
+    """Return the transpose of an array."""
+    return np.asarray(arr).T
+
+
+def array_sums(arr):
+    """Return total, row-wise and column-wise sums."""
+    a = np.asarray(arr)
+    return {
+        "total": a.sum(),
+        "row_sum": a.sum(axis=1),
+        "column_sum": a.sum(axis=0),
+    }
+
+
+def even_numbers(arr):
+    """Return even elements using Boolean indexing."""
+    a = np.asarray(arr)
+    return a[a % 2 == 0]
+
+
+def center_slice(arr):
+    """Return the center 3x3 section of a 5x5-style matrix."""
+    a = np.asarray(arr)
+    return a[1:4, 1:4]
+
+
+def reverse_array(arr):
+    """Reverse an array along both dimensions."""
+    a = np.asarray(arr)
+    return a[::-1, ::-1]
+
+
+def flatten_array(arr):
+    """Return all elements in one dimension."""
+    return np.asarray(arr).flatten()

pythonlabtools/pandas_tools.py

@@ -0,0 +1,64 @@
+"""Pandas helpers for common lab questions."""
+
+import pandas as pd
+
+
+def series_to_dataframe(name, age, course, marks):
+    """Create a DataFrame from four Series/lists."""
+    return pd.DataFrame({
+        "Name": name,
+        "Age": age,
+        "Course": course,
+        "Marks": marks,
+    })
+
+
+def add_pass_fail(df, marks_column="Marks", result_column="Result"):
+    """Add Pass/Fail using marks >= 40."""
+    result = df.copy()
+    result[result_column] = result[marks_column].apply(
+        lambda x: "Pass" if x >= 40 else "Fail"
+    )
+    return result
+
+
+def passed_students(df, result_column="Result"):
+    """Return only rows marked Pass."""
+    return df[df[result_column] == "Pass"].copy()
+
+
+def average_by_group(df, group_column, value_column):
+    """Average value for each group."""
+    return df.groupby(group_column)[value_column].mean()
+
+
+def highest_salary_employee(df, salary_column="Salary"):
+    """Return the row containing the highest salary."""
+    return df.loc[df[salary_column].idxmax()]
+
+
+def concat_rows(df1, df2, ignore_index=True):
+    """Join DataFrames vertically."""
+    return pd.concat([df1, df2], ignore_index=ignore_index)
+
+
+def concat_columns(df1, df2):
+    """Join DataFrames horizontally."""
+    return pd.concat([df1, df2], axis=1)
+
+
+def merge_dataframes(df1, df2, on, how="inner"):
+    """Merge DataFrames on a common column."""
+    return pd.merge(df1, df2, on=on, how=how)
+
+
+def value_counts_all(df):
+    """Count occurrences of complete rows."""
+    return df.value_counts()
+
+
+def group_age_statistics(df, group_column="school", age_column="age"):
+    """Return mean, min and max age for each group."""
+    return df.groupby(group_column)[age_column].agg(
+        ["mean", "min", "max"]
+    )

pythonlabtools/plotting.py

@@ -0,0 +1,141 @@
+"""Matplotlib plotting helpers."""
+
+import matplotlib.pyplot as plt
+
+
+def line_plot(x, y, title="Line Plot", xlabel="X", ylabel="Y",
+              marker=None, rotation=0):
+    plt.figure(figsize=(8, 5))
+    plt.plot(x, y, marker=marker)
+    plt.title(title)
+    plt.xlabel(xlabel)
+    plt.ylabel(ylabel)
+    if rotation:
+        plt.xticks(rotation=rotation)
+    plt.tight_layout()
+    plt.show()
+
+
+def bar_plot(x, y, title="Bar Plot", xlabel="X", ylabel="Y",
+             rotation=0):
+    plt.figure(figsize=(8, 5))
+    plt.bar(x, y)
+    plt.title(title)
+    plt.xlabel(xlabel)
+    plt.ylabel(ylabel)
+    if rotation:
+        plt.xticks(rotation=rotation)
+    plt.tight_layout()
+    plt.show()
+
+
+def scatter_plot(x, y, title="Scatter Plot", xlabel="X", ylabel="Y"):
+    plt.figure(figsize=(8, 5))
+    plt.scatter(x, y)
+    plt.title(title)
+    plt.xlabel(xlabel)
+    plt.ylabel(ylabel)
+    plt.tight_layout()
+    plt.show()
+
+
+def histogram(data, bins=10, title="Histogram",
+              xlabel="Value", ylabel="Frequency", label=None):
+    plt.figure(figsize=(8, 5))
+    plt.hist(data, bins=bins, label=label)
+    plt.title(title)
+    plt.xlabel(xlabel)
+    plt.ylabel(ylabel)
+    if label:
+        plt.legend()
+    plt.tight_layout()
+    plt.show()
+
+
+def multiple_plots(x, ys, titles=None, plot_types=None,
+                   figsize=(10, 8)):
+    if titles is None:
+        titles = [f"Plot {i+1}" for i in range(len(ys))]
+    if plot_types is None:
+        plot_types = ["line"] * len(ys)
+
+    plt.figure(figsize=figsize)
+
+    for i, (y, title, kind) in enumerate(
+        zip(ys, titles, plot_types), start=1
+    ):
+        plt.subplot(2, 2, i)
+
+        if kind == "line":
+            plt.plot(x, y)
+        elif kind == "bar":
+            plt.bar(x, y)
+        elif kind == "scatter":
+            plt.scatter(x, y)
+        elif kind == "hist":
+            plt.hist(y)
+        else:
+            raise ValueError(
+                "plot_types must be line, bar, scatter or hist"
+            )
+
+        plt.title(title)
+
+    plt.tight_layout()
+    plt.show()
+
+
+def correlation_heatmap(df, figsize=(10, 8),
+                        title="Correlation Heatmap"):
+    corr = df.corr(numeric_only=True)
+
+    plt.figure(figsize=figsize)
+    plt.imshow(corr, aspect="auto")
+    plt.colorbar()
+
+    plt.xticks(
+        range(len(corr.columns)),
+        corr.columns,
+        rotation=90
+    )
+    plt.yticks(
+        range(len(corr.columns)),
+        corr.columns
+    )
+
+    plt.title(title)
+    plt.tight_layout()
+    plt.show()
+
+    return corr
+
+
+def box_plot(df, column, by=None, title="Box Plot"):
+    plt.figure(figsize=(8, 5))
+
+    if by is None:
+        plt.boxplot(df[column].dropna())
+        plt.ylabel(column)
+    else:
+        groups = []
+        labels = []
+
+        for name, group in df.groupby(by):
+            groups.append(group[column].dropna())
+            labels.append(str(name))
+
+        plt.boxplot(groups)
+        plt.xticks(
+            range(1, len(labels) + 1),
+            labels
+        )
+        plt.ylabel(column)
+
+    plt.title(title)
+    plt.tight_layout()
+    plt.show()
+
+
+if __name__ == "__main__":
+    print("pythonlabtools.plotting: All dependencies loaded successfully.")
+

pythonlabtools/preprocessing.py

@@ -0,0 +1,133 @@
+"""Data cleaning and preprocessing helpers."""
+
+import pandas as pd
+from sklearn.preprocessing import StandardScaler
+from sklearn.model_selection import train_test_split
+
+
+def show_missing(df):
+    result = df.isnull().sum()
+    print(result)
+    return result
+
+
+def drop_missing(df, axis=0):
+    return df.dropna(axis=axis).copy()
+
+
+def fill_missing_mean(df, column):
+    df = df.copy()
+    df[column] = df[column].fillna(df[column].mean())
+    return df
+
+
+def fill_missing_median(df, column):
+    df = df.copy()
+    df[column] = df[column].fillna(df[column].median())
+    return df
+
+
+def fill_missing_mode(df, column):
+    df = df.copy()
+    mode = df[column].mode()
+    if len(mode):
+        df[column] = df[column].fillna(mode.iloc[0])
+    return df
+
+
+def convert_numeric(df, column, errors="coerce"):
+    df = df.copy()
+    df[column] = pd.to_numeric(df[column], errors=errors)
+    return df
+
+
+def remove_duplicates(df):
+    return df.drop_duplicates().copy()
+
+
+def replace_invalid(df, column, condition, replacement=None):
+    """
+    Replace values where condition(value) is True.
+    Example:
+        replace_invalid(df, "Age", lambda x: x < 0)
+    """
+    df = df.copy()
+    mask = df[column].apply(condition)
+    df.loc[mask, column] = replacement
+    return df
+
+
+def encode_categorical(df, columns=None, drop_first=False):
+    df = df.copy()
+    if columns is None:
+        columns = df.select_dtypes(
+            include=["object", "category"]
+        ).columns.tolist()
+    return pd.get_dummies(
+        df, columns=columns, drop_first=drop_first, dtype=int
+    )
+
+
+def scale_features(df, columns):
+    df = df.copy()
+    scaler = StandardScaler()
+    df[columns] = scaler.fit_transform(df[columns])
+    return df, scaler
+
+
+def train_test_scale(X, y, test_size=0.2, random_state=42, stratify=None):
+    X_train, X_test, y_train, y_test = train_test_split(
+        X, y,
+        test_size=test_size,
+        random_state=random_state,
+        stratify=stratify
+    )
+    scaler = StandardScaler()
+    X_train_scaled = scaler.fit_transform(X_train)
+    X_test_scaled = scaler.transform(X_test)
+    return X_train_scaled, X_test_scaled, y_train, y_test, scaler
+
+
+def preprocess_basic(
+    df,
+    fill_numeric="mean",
+    encode=True,
+    scale_columns=None
+):
+    """Basic cleaning pipeline for lab practice."""
+    df = df.copy()
+
+    numeric_cols = df.select_dtypes(
+        include="number"
+    ).columns.tolist()
+
+    categorical_cols = df.select_dtypes(
+        include=["object", "category"]
+    ).columns.tolist()
+
+    for col in numeric_cols:
+        if df[col].isnull().any():
+            if fill_numeric == "median":
+                df[col] = df[col].fillna(df[col].median())
+            else:
+                df[col] = df[col].fillna(df[col].mean())
+
+    for col in categorical_cols:
+        if df[col].isnull().any():
+            mode = df[col].mode()
+            if len(mode):
+                df[col] = df[col].fillna(mode.iloc[0])
+
+    if encode and categorical_cols:
+        df = pd.get_dummies(df, columns=categorical_cols, dtype=int)
+
+    if scale_columns:
+        existing = [
+            c for c in scale_columns
+            if c in df.columns
+        ]
+        if existing:
+            scaler = StandardScaler()
+            df[existing] = scaler.fit_transform(df[existing])
+
+    return df

pythonlabtools/regression.py

@@ -0,0 +1,53 @@
+"""Regression model helpers for Q49-style lab programs."""
+
+import numpy as np
+from sklearn.linear_model import LinearRegression
+from sklearn.tree import DecisionTreeRegressor
+from sklearn.ensemble import RandomForestRegressor
+from sklearn.metrics import (
+    r2_score,
+    mean_absolute_error,
+    mean_squared_error,
+)
+
+
+def train_regression_models(X_train, X_test, y_train, y_test):
+    """
+    Train three common regression models.
+    Returns predictions and models.
+    """
+    models = {
+        "Linear Regression": LinearRegression(),
+        "Decision Tree": DecisionTreeRegressor(random_state=42),
+        "Random Forest": RandomForestRegressor(
+            n_estimators=100,
+            random_state=42
+        ),
+    }
+
+    predictions = {}
+    trained_models = {}
+
+    for name, model in models.items():
+        model.fit(X_train, y_train)
+        predictions[name] = model.predict(X_test)
+        trained_models[name] = model
+
+    return trained_models, predictions
+
+
+def evaluate_regression(y_test, predictions):
+    """Calculate R2, MAE, MSE and RMSE."""
+    results = {}
+
+    for name, pred in predictions.items():
+        mse = mean_squared_error(y_test, pred)
+
+        results[name] = {
+            "R2": r2_score(y_test, pred),
+            "MAE": mean_absolute_error(y_test, pred),
+            "MSE": mse,
+            "RMSE": np.sqrt(mse),
+        }
+
+    return results

pythonlabtools-2.0.0.dist-info/METADATA

@@ -0,0 +1,109 @@
+Metadata-Version: 2.4
+Name: pythonlabtools
+Version: 2.0.0
+Summary: Reusable Python lab exam toolkit for NumPy, Pandas, preprocessing, plotting and machine learning.
+Author: JP
+License: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.23
+Requires-Dist: pandas>=1.5
+Requires-Dist: matplotlib>=3.6
+Requires-Dist: scikit-learn>=1.2
+
+# PythonLabTools — Python Lab Exam Toolkit
+
+Version 2.0.0
+
+This package turns common Python lab-exam programs into reusable functions.
+
+## Covered areas
+
+- NumPy arrays and slicing
+- Pandas DataFrames, filtering, grouping, joining and merging
+- Missing values and dirty-data preprocessing
+- Categorical encoding
+- Feature scaling and train/test splitting
+- Line, bar, scatter, histogram and multiple plots
+- Correlation heatmaps
+- Regression: Linear Regression, Decision Tree, Random Forest
+- Classification: Logistic Regression, Decision Tree, Random Forest
+- Classification metrics and confusion matrix
+- K-Means clustering and Elbow method
+- PCA
+- Association-rule calculations: support, confidence and lift
+- Simple SQLite CRUD helpers
+- Exam templates
+
+## Install locally
+
+Extract the ZIP, open a terminal in the extracted folder:
+
+```bash
+pip install .
+```
+
+Then:
+
+```python
+from pythonlabtools import *
+```
+
+## Google Colab
+
+Upload the ZIP, extract it, and install:
+
+```python
+!unzip -q /content/pythonlabtools-exam-toolkit-v2.zip -d /content/
+!pip install /content/pythonlabtools_exam_toolkit
+```
+
+Or after extracting:
+
+```python
+%cd /content/pythonlabtools_exam_toolkit
+!pip install .
+```
+
+## Example
+
+```python
+import pandas as pd
+from pythonlabtools import show_missing, fill_missing_mean
+from pythonlabtools import line_plot
+
+df = pd.DataFrame({
+    "Day": ["Mon", "Tue", "Wed"],
+    "Temperature": [30, None, 32]
+})
+
+show_missing(df)
+df = fill_missing_mean(df, "Temperature")
+
+line_plot(
+    df["Day"],
+    df["Temperature"],
+    title="Temperature vs Day",
+    xlabel="Day",
+    ylabel="Temperature"
+)
+```
+
+## Important exam principle
+
+Use the toolkit to save typing, but understand what each function does.
+In a viva, you should be able to explain:
+
+- `groupby`
+- `concat`
+- `merge`
+- `fillna`
+- `get_dummies`
+- `StandardScaler`
+- `train_test_split`
+- `fit`
+- `predict`
+- R2 / MAE / MSE / RMSE
+- accuracy / recall / confusion matrix
+- K-Means / inertia / PCA
+- support / confidence / lift

pythonlabtools-2.0.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+pythonlabtools/__init__.py,sha256=j9IVD_niyxORkDr-3glnjKh6JvbgkCfyxZRFY9x6bkM,685
+pythonlabtools/association.py,sha256=iM1Fko-OlwSvbpsYqmBC8f1dEYDBZnR3EV3X43mvK9s,2400
+pythonlabtools/classification.py,sha256=ecUJDd8uhuPWDjcO8Y87UzSunIsTaSsWwTRT_wS5MA0,2315
+pythonlabtools/clustering.py,sha256=9U_RLKyhxRsmMy9EiP0Ca5bBz5ToTbEGcSzARnwAUpA,1410
+pythonlabtools/code_viewer.py,sha256=w6okpilnvc5stvhTBw6QhUd1391YAgjDIWb--9agvbg,7141
+pythonlabtools/database.py,sha256=y2Gpw-cFKH4pessCBWflpxoCbD8auOKx2QIBH1PA3ro,976
+pythonlabtools/numpy_tools.py,sha256=YjW5RKGtSldB_VoKy3OnjIJgq2D_2o2Z2ATEDsPnLtk,1176
+pythonlabtools/pandas_tools.py,sha256=kNS5iWVcyMQreG9l-N_t-63n34VTPEPylCX2qNARyJ0,1743
+pythonlabtools/plotting.py,sha256=nBPAILvEsIjOFZ4PLweCeePn0nkXNcg5_TmBAfr99YY,3208
+pythonlabtools/preprocessing.py,sha256=Nz4-vOT9PFphRFTpS7WbrisXXeffYG6o_l99nYQ2qpU,3321
+pythonlabtools/regression.py,sha256=XCBhC89CocbbM5uF4Wfhj3TcukGQrZl51NC-0OtWCgQ,1392
+pythonlabtools-2.0.0.dist-info/METADATA,sha256=5xiBfKix0f4MCAsFtlWY3wEme-reOEKaDBw4q4DflP4,2486
+pythonlabtools-2.0.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+pythonlabtools-2.0.0.dist-info/top_level.txt,sha256=uxOSGRTQvMM4cnMtmUI0QKMe3VXO9glKbaIvNS8HE2A,15
+pythonlabtools-2.0.0.dist-info/RECORD,,

pythonlabtools-2.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pythonlabtools-2.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pythonlabtools