pythonlabtools 2.0.0__tar.gz

pythonlabtools-2.0.0/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,96 @@
+# 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/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pythonlabtools"
+version = "2.0.0"
+description = "Reusable Python lab exam toolkit for NumPy, Pandas, preprocessing, plotting and machine learning."
+readme = "README.md"
+requires-python = ">=3.9"
+license = {text = "MIT"}
+
+authors = [
+    {name = "JP"}
+]
+
+dependencies = [
+    "numpy>=1.23",
+    "pandas>=1.5",
+    "matplotlib>=3.6",
+    "scikit-learn>=1.2"
+]
+
+[tool.setuptools.packages.find]
+include = ["pythonlabtools*"]

pythonlabtools-2.0.0/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-2.0.0/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-2.0.0/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-2.0.0/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()