scikit-tools 0.1.1__tar.gz → 0.2.0__tar.gz

scikit_tools-0.2.0/PKG-INFO

@@ -0,0 +1,61 @@
+Metadata-Version: 2.4
+Name: scikit-tools
+Version: 0.2.0
+Summary: Thirteen runnable, straight-through scikit-learn and data-analysis examples
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: ipython
+Requires-Dist: matplotlib
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: scikit-learn
+Requires-Dist: scipy
+Requires-Dist: seaborn
+
+# scikit-tools
+
+`scikit-tools` provides 13 standalone, straight-through Python examples. Each
+topic file contains its own imports, dataset setup, and analysis code; examples
+are not hidden inside functions.
+
+## Install from a local checkout
+
+```console
+python -m pip install -e .
+```
+
+This installs the package and its dependencies. Each topic loads the Iris
+dataset provided by `sklearn.datasets.load_iris`, formats its columns to match
+the examples, and does not download or write a CSV file.
+
+## Open or run a topic
+
+```console
+python -m scikit_tools.numpy_stats
+python -m scikit_tools.pca
+```
+
+You can also open any topic script under `scikit_tools` directly in your
+editor, inspect or copy its raw code, and run it with the editor's Python run
+command. These are scripts: importing one executes its example.
+
+## Topics
+
+1. NumPy statistics (`numpy_stats.py`)
+2. Inspecting the Iris dataset (`inspect_dataset.py`)
+3. Handling missing values (`missing_values.py`)
+4. Data transformation (`data_transformation.py`)
+5. Histogram and scatter-plot EDA (`eda_plots.py`)
+6. Box plot and IQR outlier detection (`outlier_detection.py`)
+7. Descriptive statistics (`descriptive_stats.py`)
+8. Correlation and covariance (`correlation_covariance.py`)
+9. Independent-samples t-test (`hypothesis_testing.py`)
+10. Linear regression (`linear_regression.py`)
+11. Logistic-regression classification (`logistic_regression.py`)
+12. K-means clustering (`kmeans_clustering.py`)
+13. PCA and classification (`pca.py`)
+
+The examples use the Iris columns `SepalLengthCm`, `SepalWidthCm`,
+`PetalLengthCm`, `PetalWidthCm`, and `Species`. The species names use the
+`Iris-setosa` style. The missing values example intentionally adds missing values to a DataFrame
+copy and fills them; it does not change the source dataset.

scikit_tools-0.2.0/README.md

@@ -0,0 +1,32 @@
+# IEEEXtreme Python Toolkit & OA / DSA Practice
+
+A reusable, contest-oriented reference library and practice repository for advanced DSA, Online Assessments (OA), and competition simulations.
+
+## DSA & OA Practice Problems
+
+| # | Problem | Key Topics & Algorithms | Solutions |
+|---|---|---|---|
+| 01 | [Tree Vector Norm Maximization](problems/tree_vector_norm/EXPLANATION.md) | Tree DP, Convex Duality, QuickHull, Branch-and-Bound Pruning | [Python](problems/tree_vector_norm/solution.py), [C++](problems/tree_vector_norm/solution.cpp), [Tests](problems/tree_vector_norm/test_solution.py) |
+
+## Toolkit Contents
+
+- `template.py` — compact starting template suitable for copying into an editor.
+- `io_utils.py` — fast token input, parsing, and output helpers.
+- `sorting_searching.py`, `two_pointers.py` — common array patterns.
+- `data_structures.py` — DSU, Fenwick and segment trees, trie, monotonic structures.
+- `graphs.py`, `advanced_graphs.py` — traversals, shortest paths, MST, SCC, bridges, LCA, Euler tours.
+- `dynamic_programming.py`, `number_theory.py`, `combinatorics.py`, `strings.py`, `geometry.py`, `bitwise.py`, `backtracking.py`.
+- `docs/` — API notes, assumptions, and complexity guide.
+- `tests/` — unit tests for representative edge cases and algorithms.
+- `category_templates.py` — focused patterns mapped to every category visible in the supplied screenshot.
+- `docs/category-map.md` — category-to-snippet index, archive research notes, and platform-use boundary.
+
+## Use
+
+Copy `template.py` as the actual contest starting file, then add only the needed algorithm snippets. Import library code locally while practicing, for example `from graphs import dijkstra`. Some contest editors accept only one submitted file, so copy required functions/classes into that file when needed. No package installation is required.
+
+Run checks from this directory with `python -m unittest discover -s tests -v`.
+
+## Notes
+
+These are general algorithms, not task-specific solutions. Check each docstring for indexing, weight, and input assumptions. Python integers are arbitrary precision. Graph vertices and sequence positions are zero-indexed unless stated otherwise. Dijkstra requires nonnegative edge weights. The library is for local reference and practice; platform upload availability and competition rules are determined by the platform/organizers.

scikit_tools-0.2.0/SCIKIT_TOOLS.md

@@ -0,0 +1,47 @@
+# scikit-tools
+
+`scikit-tools` provides 13 standalone, straight-through Python examples. Each
+topic file contains its own imports, dataset setup, and analysis code; examples
+are not hidden inside functions.
+
+## Install from a local checkout
+
+```console
+python -m pip install -e .
+```
+
+This installs the package and its dependencies. Each topic loads the Iris
+dataset provided by `sklearn.datasets.load_iris`, formats its columns to match
+the examples, and does not download or write a CSV file.
+
+## Open or run a topic
+
+```console
+python -m scikit_tools.numpy_stats
+python -m scikit_tools.pca
+```
+
+You can also open any topic script under `scikit_tools` directly in your
+editor, inspect or copy its raw code, and run it with the editor's Python run
+command. These are scripts: importing one executes its example.
+
+## Topics
+
+1. NumPy statistics (`numpy_stats.py`)
+2. Inspecting the Iris dataset (`inspect_dataset.py`)
+3. Handling missing values (`missing_values.py`)
+4. Data transformation (`data_transformation.py`)
+5. Histogram and scatter-plot EDA (`eda_plots.py`)
+6. Box plot and IQR outlier detection (`outlier_detection.py`)
+7. Descriptive statistics (`descriptive_stats.py`)
+8. Correlation and covariance (`correlation_covariance.py`)
+9. Independent-samples t-test (`hypothesis_testing.py`)
+10. Linear regression (`linear_regression.py`)
+11. Logistic-regression classification (`logistic_regression.py`)
+12. K-means clustering (`kmeans_clustering.py`)
+13. PCA and classification (`pca.py`)
+
+The examples use the Iris columns `SepalLengthCm`, `SepalWidthCm`,
+`PetalLengthCm`, `PetalWidthCm`, and `Species`. The species names use the
+`Iris-setosa` style. The missing values example intentionally adds missing values to a DataFrame
+copy and fills them; it does not change the source dataset.

scikit_tools-0.2.0/pyproject.toml

@@ -0,0 +1,22 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "scikit-tools"
+version = "0.2.0"
+description = "Thirteen runnable, straight-through scikit-learn and data-analysis examples"
+readme = "SCIKIT_TOOLS.md"
+requires-python = ">=3.10"
+dependencies = [
+    "ipython",
+    "matplotlib",
+    "numpy",
+    "pandas",
+    "scikit-learn",
+    "scipy",
+    "seaborn",
+]
+
+[tool.setuptools]
+packages = ["scikit_tools"]

scikit_tools-0.2.0/scikit_tools/__init__.py

@@ -0,0 +1 @@
+"""Runnable, straight-through examples for 13 scikit-learn/data-analysis topics."""

scikit_tools-0.2.0/scikit_tools/correlation_covariance.py

@@ -0,0 +1,19 @@
+import pandas as pd
+from sklearn.datasets import load_iris
+
+iris = load_iris(as_frame=True)
+df = iris.data.rename(columns={
+    'sepal length (cm)': 'SepalLengthCm',
+    'sepal width (cm)': 'SepalWidthCm',
+    'petal length (cm)': 'PetalLengthCm',
+    'petal width (cm)': 'PetalWidthCm'
+})
+df['Species'] = iris.target.map({
+    index: f'Iris-{name}' for index, name in enumerate(iris.target_names)
+})
+
+covariance_val = df['PetalLengthCm'].cov(df['PetalWidthCm'])
+correlation_val = df['PetalLengthCm'].corr(df['PetalWidthCm'])
+
+print(f"Covariance: {covariance_val:.4f}")
+print(f"Correlation Coefficient: {correlation_val:.4f}")

scikit_tools-0.2.0/scikit_tools/data_transformation.py

@@ -0,0 +1,26 @@
+import pandas as pd
+from IPython.display import display
+from sklearn.datasets import load_iris
+from sklearn.preprocessing import StandardScaler
+
+iris = load_iris(as_frame=True)
+df = iris.data.rename(columns={
+    'sepal length (cm)': 'SepalLengthCm',
+    'sepal width (cm)': 'SepalWidthCm',
+    'petal length (cm)': 'PetalLengthCm',
+    'petal width (cm)': 'PetalWidthCm'
+})
+df['Species'] = iris.target.map({
+    index: f'Iris-{name}' for index, name in enumerate(iris.target_names)
+})
+
+# One-hot encoding for Species
+df_encoded = pd.get_dummies(df, columns=['Species'])
+
+# Standardize numerical attributes
+num_cols = ['SepalLengthCm', 'SepalWidthCm', 'PetalLengthCm', 'PetalWidthCm']
+scaler = StandardScaler()
+df_encoded[num_cols] = scaler.fit_transform(df_encoded[num_cols])
+
+print("--- Transformed Data Preview ---")
+display(df_encoded.head())

scikit_tools-0.2.0/scikit_tools/descriptive_stats.py

@@ -0,0 +1,24 @@
+import pandas as pd
+from IPython.display import display
+from sklearn.datasets import load_iris
+
+iris = load_iris(as_frame=True)
+df = iris.data.rename(columns={
+    'sepal length (cm)': 'SepalLengthCm',
+    'sepal width (cm)': 'SepalWidthCm',
+    'petal length (cm)': 'PetalLengthCm',
+    'petal width (cm)': 'PetalWidthCm'
+})
+df['Species'] = iris.target.map({
+    index: f'Iris-{name}' for index, name in enumerate(iris.target_names)
+})
+
+attributes = ['SepalLengthCm', 'PetalLengthCm']
+stats_summary = pd.DataFrame({
+    'Mean': df[attributes].mean(),
+    'Median': df[attributes].median(),
+    'Sample Variance': df[attributes].var(),
+    'Standard Deviation': df[attributes].std()
+})
+
+display(stats_summary)

scikit_tools-0.2.0/scikit_tools/eda_plots.py

@@ -0,0 +1,34 @@
+import pandas as pd
+import matplotlib.pyplot as plt
+import seaborn as sns
+from sklearn.datasets import load_iris
+
+iris = load_iris(as_frame=True)
+df = iris.data.rename(columns={
+    'sepal length (cm)': 'SepalLengthCm',
+    'sepal width (cm)': 'SepalWidthCm',
+    'petal length (cm)': 'PetalLengthCm',
+    'petal width (cm)': 'PetalWidthCm'
+})
+df['Species'] = iris.target.map({
+    index: f'Iris-{name}' for index, name in enumerate(iris.target_names)
+})
+
+plt.figure(figsize=(14, 5))
+
+# Histogram
+plt.subplot(1, 2, 1)
+sns.histplot(data=df, x='PetalLengthCm', kde=True, color='skyblue')
+plt.title('Histogram of PetalLengthCm')
+plt.xlabel('Petal Length (cm)')
+plt.ylabel('Frequency')
+
+# Scatter Plot
+plt.subplot(1, 2, 2)
+sns.scatterplot(data=df, x='SepalLengthCm', y='PetalLengthCm', hue='Species', palette='Set1')
+plt.title('SepalLengthCm vs PetalLengthCm')
+plt.xlabel('Sepal Length (cm)')
+plt.ylabel('Petal Length (cm)')
+
+plt.tight_layout()
+plt.show()

scikit_tools-0.2.0/scikit_tools/hypothesis_testing.py

@@ -0,0 +1,22 @@
+import pandas as pd
+from scipy import stats
+from sklearn.datasets import load_iris
+
+iris = load_iris(as_frame=True)
+df = iris.data.rename(columns={
+    'sepal length (cm)': 'SepalLengthCm',
+    'sepal width (cm)': 'SepalWidthCm',
+    'petal length (cm)': 'PetalLengthCm',
+    'petal width (cm)': 'PetalWidthCm'
+})
+df['Species'] = iris.target.map({
+    index: f'Iris-{name}' for index, name in enumerate(iris.target_names)
+})
+
+setosa_sepal = df[df['Species'] == 'Iris-setosa']['SepalLengthCm']
+versicolor_sepal = df[df['Species'] == 'Iris-versicolor']['SepalLengthCm']
+
+t_stat, p_val = stats.ttest_ind(setosa_sepal, versicolor_sepal, equal_var=False)
+
+print(f"T-statistic: {t_stat:.4f}")
+print(f"P-value: {p_val:.4e}")

scikit_tools-0.2.0/scikit_tools/inspect_dataset.py

@@ -0,0 +1,28 @@
+import pandas as pd
+from IPython.display import display
+from sklearn.datasets import load_iris
+
+iris = load_iris(as_frame=True)
+df = iris.data.rename(columns={
+    'sepal length (cm)': 'SepalLengthCm',
+    'sepal width (cm)': 'SepalWidthCm',
+    'petal length (cm)': 'PetalLengthCm',
+    'petal width (cm)': 'PetalWidthCm'
+})
+df['Species'] = iris.target.map({
+    index: f'Iris-{name}' for index, name in enumerate(iris.target_names)
+})
+
+print("--- First 5 Records ---")
+display(df.head())
+
+print(f"\nNumber of rows: {df.shape[0]}, Number of columns: {df.shape[1]}")
+
+print("\n--- Column Names & Data Types ---")
+print(df.dtypes)
+
+print("\n--- Summary Statistics ---")
+display(df.describe())
+
+print("\nNumerical attributes: SepalLengthCm, SepalWidthCm, PetalLengthCm, PetalWidthCm")
+print("Target column: Species")

scikit_tools-0.2.0/scikit_tools/kmeans_clustering.py

@@ -0,0 +1,29 @@
+import pandas as pd
+import matplotlib.pyplot as plt
+import seaborn as sns
+from IPython.display import display
+from sklearn.datasets import load_iris
+from sklearn.cluster import KMeans
+
+iris = load_iris(as_frame=True)
+df = iris.data.rename(columns={
+    'sepal length (cm)': 'SepalLengthCm',
+    'sepal width (cm)': 'SepalWidthCm',
+    'petal length (cm)': 'PetalLengthCm',
+    'petal width (cm)': 'PetalWidthCm'
+})
+df['Species'] = iris.target.map({
+    index: f'Iris-{name}' for index, name in enumerate(iris.target_names)
+})
+
+X = df[['SepalLengthCm', 'SepalWidthCm', 'PetalLengthCm', 'PetalWidthCm']]
+
+kmeans = KMeans(n_clusters=3, random_state=42, n_init='auto')
+df['Cluster'] = kmeans.fit_predict(X)
+
+plt.figure(figsize=(6, 4))
+sns.scatterplot(data=df, x='SepalLengthCm', y='PetalLengthCm', hue='Cluster', palette='Set1')
+plt.title('K-Means Clustering Assignments (k=3)')
+plt.show()
+
+display(df[['SepalLengthCm', 'PetalLengthCm', 'Species', 'Cluster']].head())

scikit_tools-0.2.0/scikit_tools/linear_regression.py

@@ -0,0 +1,32 @@
+import pandas as pd
+from IPython.display import display
+from sklearn.datasets import load_iris
+from sklearn.model_selection import train_test_split
+from sklearn.linear_model import LinearRegression
+
+iris = load_iris(as_frame=True)
+df = iris.data.rename(columns={
+    'sepal length (cm)': 'SepalLengthCm',
+    'sepal width (cm)': 'SepalWidthCm',
+    'petal length (cm)': 'PetalLengthCm',
+    'petal width (cm)': 'PetalWidthCm'
+})
+df['Species'] = iris.target.map({
+    index: f'Iris-{name}' for index, name in enumerate(iris.target_names)
+})
+
+X = df[['SepalLengthCm', 'SepalWidthCm', 'PetalWidthCm']]
+y = df['PetalLengthCm']
+
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+
+model = LinearRegression()
+model.fit(X_train, y_train)
+
+predictions = model.predict(X_test)
+
+print("Model Coefficients:", {col: coef for col, coef in zip(X.columns, model.coef_)})
+print("Intercept:", model.intercept_)
+
+results = pd.DataFrame({'Actual': y_test, 'Predicted': predictions})
+display(results.head())

scikit_tools-0.2.0/scikit_tools/logistic_regression.py

@@ -0,0 +1,30 @@
+import pandas as pd
+from sklearn.datasets import load_iris
+from sklearn.model_selection import train_test_split
+from sklearn.linear_model import LogisticRegression
+from sklearn.metrics import accuracy_score, confusion_matrix
+
+iris = load_iris(as_frame=True)
+df = iris.data.rename(columns={
+    'sepal length (cm)': 'SepalLengthCm',
+    'sepal width (cm)': 'SepalWidthCm',
+    'petal length (cm)': 'PetalLengthCm',
+    'petal width (cm)': 'PetalWidthCm'
+})
+df['Species'] = iris.target.map({
+    index: f'Iris-{name}' for index, name in enumerate(iris.target_names)
+})
+
+X = df[['SepalLengthCm', 'SepalWidthCm', 'PetalLengthCm', 'PetalWidthCm']]
+y = df['Species']
+
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+
+clf = LogisticRegression(max_iter=200)
+clf.fit(X_train, y_train)
+
+y_pred = clf.predict(X_test)
+
+print(f"Accuracy: {accuracy_score(y_test, y_pred):.4f}")
+print("\nConfusion Matrix:")
+print(confusion_matrix(y_test, y_pred))

scikit_tools-0.2.0/scikit_tools/missing_values.py

@@ -0,0 +1,33 @@
+import pandas as pd
+import numpy as np
+from sklearn.datasets import load_iris
+
+iris = load_iris(as_frame=True)
+df = iris.data.rename(columns={
+    'sepal length (cm)': 'SepalLengthCm',
+    'sepal width (cm)': 'SepalWidthCm',
+    'petal length (cm)': 'PetalLengthCm',
+    'petal width (cm)': 'PetalWidthCm'
+})
+df['Species'] = iris.target.map({
+    index: f'Iris-{name}' for index, name in enumerate(iris.target_names)
+})
+df_copy = df.copy()
+
+# Introduce missing values
+df_copy.loc[[5, 10, 15], 'SepalLengthCm'] = np.nan
+df_copy.loc[[20, 25], 'Species'] = np.nan
+
+print("--- Missing Value Count Before Imputation ---")
+print(df_copy.isnull().sum())
+
+# Impute numerical missing values with median
+median_sepal = df_copy['SepalLengthCm'].median()
+df_copy['SepalLengthCm'] = df_copy['SepalLengthCm'].fillna(median_sepal)
+
+# Impute categorical missing values with mode
+mode_species = df_copy['Species'].mode()[0]
+df_copy['Species'] = df_copy['Species'].fillna(mode_species)
+
+print("\n--- Missing Value Count After Imputation ---")
+print(df_copy.isnull().sum())

scikit_tools-0.2.0/scikit_tools/numpy_stats.py

@@ -0,0 +1,31 @@
+import pandas as pd
+import numpy as np
+from sklearn.datasets import load_iris
+
+iris = load_iris(as_frame=True)
+df = iris.data.rename(columns={
+    'sepal length (cm)': 'SepalLengthCm',
+    'sepal width (cm)': 'SepalWidthCm',
+    'petal length (cm)': 'PetalLengthCm',
+    'petal width (cm)': 'PetalWidthCm'
+})
+df['Species'] = iris.target.map({
+    index: f'Iris-{name}' for index, name in enumerate(iris.target_names)
+})
+
+# Select SepalLengthCm and convert to NumPy array
+sepal_length = df['SepalLengthCm'].to_numpy()
+
+# Calculate basic statistics
+total_sum = np.sum(sepal_length)
+mean_val = np.mean(sepal_length)
+max_val = np.max(sepal_length)
+min_val = np.min(sepal_length)
+first_five = sepal_length[:5]
+
+# Display results
+print(f"Sum: {total_sum:.2f}")
+print(f"Mean: {mean_val:.2f}")
+print(f"Maximum: {max_val:.2f}")
+print(f"Minimum: {min_val:.2f}")
+print(f"First five values: {first_five}")

scikit_tools-0.2.0/scikit_tools/outlier_detection.py

@@ -0,0 +1,39 @@
+import pandas as pd
+import matplotlib.pyplot as plt
+import seaborn as sns
+from IPython.display import display
+from sklearn.datasets import load_iris
+
+iris = load_iris(as_frame=True)
+df = iris.data.rename(columns={
+    'sepal length (cm)': 'SepalLengthCm',
+    'sepal width (cm)': 'SepalWidthCm',
+    'petal length (cm)': 'PetalLengthCm',
+    'petal width (cm)': 'PetalWidthCm'
+})
+df['Species'] = iris.target.map({
+    index: f'Iris-{name}' for index, name in enumerate(iris.target_names)
+})
+
+# Box Plot
+plt.figure(figsize=(6, 4))
+sns.boxplot(y=df['SepalWidthCm'], color='lightgreen')
+plt.title('Box Plot of SepalWidthCm')
+plt.ylabel('Sepal Width (cm)')
+plt.show()
+
+# Calculate IQR & Outliers
+Q1 = df['SepalWidthCm'].quantile(0.25)
+Q3 = df['SepalWidthCm'].quantile(0.75)
+IQR = Q3 - Q1
+lower_bound = Q1 - 1.5 * IQR
+upper_bound = Q3 + 1.5 * IQR
+
+outliers = df[(df['SepalWidthCm'] < lower_bound) | (df['SepalWidthCm'] > upper_bound)]
+
+print(f"Q1 (25th percentile): {Q1:.2f}")
+print(f"Q3 (75th percentile): {Q3:.2f}")
+print(f"IQR (Interquartile Range): {IQR:.2f}")
+print(f"Outlier limits: {lower_bound:.2f} to {upper_bound:.2f}")
+print(f"\nDetected Outliers:")
+display(outliers[['SepalWidthCm', 'Species']])

scikit_tools-0.2.0/scikit_tools/pca.py

@@ -0,0 +1,39 @@
+import pandas as pd
+from sklearn.datasets import load_iris
+from sklearn.preprocessing import StandardScaler
+from sklearn.decomposition import PCA
+from sklearn.model_selection import train_test_split
+from sklearn.linear_model import LogisticRegression
+from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score
+
+iris = load_iris(as_frame=True)
+df = iris.data.rename(columns={
+    'sepal length (cm)': 'SepalLengthCm',
+    'sepal width (cm)': 'SepalWidthCm',
+    'petal length (cm)': 'PetalLengthCm',
+    'petal width (cm)': 'PetalWidthCm'
+})
+df['Species'] = iris.target.map({
+    index: f'Iris-{name}' for index, name in enumerate(iris.target_names)
+})
+
+X = df[['SepalLengthCm', 'SepalWidthCm', 'PetalLengthCm', 'PetalWidthCm']]
+y = df['Species']
+
+# Standardize
+X_scaled = StandardScaler().fit_transform(X)
+
+# PCA to 2 components
+pca = PCA(n_components=2)
+X_pca = pca.fit_transform(X_scaled)
+
+X_train, X_test, y_train, y_test = train_test_split(X_pca, y, test_size=0.2, random_state=42)
+
+clf = LogisticRegression()
+clf.fit(X_train, y_train)
+y_pred = clf.predict(X_test)
+
+print(f"Accuracy: {accuracy_score(y_test, y_pred):.4f}")
+print(f"Precision (Macro): {precision_score(y_test, y_pred, average='macro'):.4f}")
+print(f"Recall (Macro): {recall_score(y_test, y_pred, average='macro'):.4f}")
+print(f"F1-Score (Macro): {f1_score(y_test, y_pred, average='macro'):.4f}")

scikit_tools-0.2.0/scikit_tools.egg-info/PKG-INFO

@@ -0,0 +1,61 @@
+Metadata-Version: 2.4
+Name: scikit-tools
+Version: 0.2.0
+Summary: Thirteen runnable, straight-through scikit-learn and data-analysis examples
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: ipython
+Requires-Dist: matplotlib
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: scikit-learn
+Requires-Dist: scipy
+Requires-Dist: seaborn
+
+# scikit-tools
+
+`scikit-tools` provides 13 standalone, straight-through Python examples. Each
+topic file contains its own imports, dataset setup, and analysis code; examples
+are not hidden inside functions.
+
+## Install from a local checkout
+
+```console
+python -m pip install -e .
+```
+
+This installs the package and its dependencies. Each topic loads the Iris
+dataset provided by `sklearn.datasets.load_iris`, formats its columns to match
+the examples, and does not download or write a CSV file.
+
+## Open or run a topic
+
+```console
+python -m scikit_tools.numpy_stats
+python -m scikit_tools.pca
+```
+
+You can also open any topic script under `scikit_tools` directly in your
+editor, inspect or copy its raw code, and run it with the editor's Python run
+command. These are scripts: importing one executes its example.
+
+## Topics
+
+1. NumPy statistics (`numpy_stats.py`)
+2. Inspecting the Iris dataset (`inspect_dataset.py`)
+3. Handling missing values (`missing_values.py`)
+4. Data transformation (`data_transformation.py`)
+5. Histogram and scatter-plot EDA (`eda_plots.py`)
+6. Box plot and IQR outlier detection (`outlier_detection.py`)
+7. Descriptive statistics (`descriptive_stats.py`)
+8. Correlation and covariance (`correlation_covariance.py`)
+9. Independent-samples t-test (`hypothesis_testing.py`)
+10. Linear regression (`linear_regression.py`)
+11. Logistic-regression classification (`logistic_regression.py`)
+12. K-means clustering (`kmeans_clustering.py`)
+13. PCA and classification (`pca.py`)
+
+The examples use the Iris columns `SepalLengthCm`, `SepalWidthCm`,
+`PetalLengthCm`, `PetalWidthCm`, and `Species`. The species names use the
+`Iris-setosa` style. The missing values example intentionally adds missing values to a DataFrame
+copy and fills them; it does not change the source dataset.

scikit_tools-0.2.0/scikit_tools.egg-info/SOURCES.txt

@@ -0,0 +1,24 @@
+README.md
+SCIKIT_TOOLS.md
+pyproject.toml
+scikit_tools/__init__.py
+scikit_tools/correlation_covariance.py
+scikit_tools/data_transformation.py
+scikit_tools/descriptive_stats.py
+scikit_tools/eda_plots.py
+scikit_tools/hypothesis_testing.py
+scikit_tools/inspect_dataset.py
+scikit_tools/kmeans_clustering.py
+scikit_tools/linear_regression.py
+scikit_tools/logistic_regression.py
+scikit_tools/missing_values.py
+scikit_tools/numpy_stats.py
+scikit_tools/outlier_detection.py
+scikit_tools/pca.py
+scikit_tools.egg-info/PKG-INFO
+scikit_tools.egg-info/SOURCES.txt
+scikit_tools.egg-info/dependency_links.txt
+scikit_tools.egg-info/requires.txt
+scikit_tools.egg-info/top_level.txt
+tests/test.py
+tests/test_scikit_tools.py

{scikit_tools-0.1.1/src → scikit_tools-0.2.0}/scikit_tools.egg-info/requires.txt

@@ -1,6 +1,7 @@
-pandas
-numpy
+ipython
 matplotlib
-seaborn
-scipy
+numpy
+pandas
 scikit-learn
+scipy
+seaborn

{scikit_tools-0.1.1 → scikit_tools-0.2.0}/setup.cfg

@@ -1,4 +1,4 @@
-[egg_info]
-tag_build = 
-tag_date = 0
-
+[egg_info]
+tag_build = 
+tag_date = 0
+

scikit_tools-0.2.0/tests/test.py

@@ -0,0 +1,31 @@
+from pathlib import Path
+import scikit_tools as st
+
+def pca_analysis(filepath='Iris.csv'):
+    """Topic 13: Standardize, compress with 2-Component PCA, and classify."""
+    import pandas as pd
+    from sklearn.preprocessing import StandardScaler
+    from sklearn.decomposition import PCA
+    from sklearn.model_selection import train_test_split
+    from sklearn.linear_model import LogisticRegression
+    from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score
+    df = pd.read_csv(filepath)
+    X = df[['SepalLengthCm', 'SepalWidthCm', 'PetalLengthCm', 'PetalWidthCm']]
+    y = df['Species']
+    X_scaled = StandardScaler().fit_transform(X)
+    pca = PCA(n_components=2)
+    X_pca = pca.fit_transform(X_scaled)
+    X_train, X_test, y_train, y_test = train_test_split(X_pca, y, test_size=0.2, random_state=42)
+    clf = LogisticRegression()
+    clf.fit(X_train, y_train)
+    y_pred = clf.predict(X_test)
+    return {
+        'accuracy': accuracy_score(y_test, y_pred),
+        'precision': precision_score(y_test, y_pred, average='macro'),
+        'recall': recall_score(y_test, y_pred, average='macro'),
+        'f1_score': f1_score(y_test, y_pred, average='macro')
+    }
+
+
+if __name__ == '__main__':
+    print(pca_analysis(Path(__file__).with_name('Iris.csv')))

scikit_tools-0.2.0/tests/test_scikit_tools.py

@@ -0,0 +1,67 @@
+import os
+from pathlib import Path
+import subprocess
+import sys
+import tempfile
+import unittest
+
+
+PROJECT_ROOT = Path(__file__).resolve().parents[1]
+TOPIC_MODULES = [
+    "numpy_stats",
+    "inspect_dataset",
+    "missing_values",
+    "data_transformation",
+    "eda_plots",
+    "outlier_detection",
+    "descriptive_stats",
+    "correlation_covariance",
+    "hypothesis_testing",
+    "linear_regression",
+    "logistic_regression",
+    "kmeans_clustering",
+    "pca",
+]
+
+
+class ScikitToolsScriptTests(unittest.TestCase):
+    def test_all_topics_run_from_a_clean_working_directory(self):
+        with tempfile.TemporaryDirectory() as working_dir:
+            env = os.environ.copy()
+            env["MPLBACKEND"] = "Agg"
+            env["PYTHONPATH"] = str(PROJECT_ROOT)
+            for idx, module in enumerate(TOPIC_MODULES, start=1):
+                with self.subTest(module=module):
+                    result = subprocess.run(
+                        [sys.executable, str(PROJECT_ROOT / "scikit_tools" / f"{module}.py")],
+                        cwd=working_dir,
+                        env=env,
+                        capture_output=True,
+                        text=True,
+                        timeout=60,
+                    )
+                    self.assertEqual(
+                        result.returncode,
+                        0,
+                        msg=f"module {module} failed:\n{result.stdout}\n{result.stderr}",
+                    )
+                    self.assertFalse((Path(working_dir) / "iris.csv").exists())
+                    if module == "missing_values":
+                        after_imputation = result.stdout.split(
+                            "--- Missing Value Count After Imputation ---", 1
+                        )[1]
+                        self.assertRegex(after_imputation, r"SepalLengthCm\s+0")
+                        self.assertRegex(after_imputation, r"Species\s+0")
+
+    def test_every_topic_loads_the_bundled_sklearn_dataset(self):
+        for module in TOPIC_MODULES:
+            with self.subTest(module=module):
+                source = (PROJECT_ROOT / "scikit_tools" / f"{module}.py").read_text(
+                    encoding="utf-8"
+                )
+                self.assertIn("from sklearn.datasets import load_iris", source)
+                self.assertNotIn("from ._common", source)
+
+
+if __name__ == "__main__":
+    unittest.main()

scikit_tools-0.1.1/PKG-INFO

@@ -1,19 +0,0 @@
-Metadata-Version: 2.4
-Name: scikit-tools
-Version: 0.1.1
-Summary: Clean, dependency-managed toolkit with fully self-contained topic functions
-Author-email: Your Name <your.email@example.com>
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-Requires-Dist: pandas
-Requires-Dist: numpy
-Requires-Dist: matplotlib
-Requires-Dist: seaborn
-Requires-Dist: scipy
-Requires-Dist: scikit-learn
-
-# scikit-tools
-A clean, streamlined scientific data science toolkit with self-contained dataset fetching and direct topic interfaces.

scikit_tools-0.1.1/README.md

@@ -1,2 +0,0 @@
-# scikit-tools
-A clean, streamlined scientific data science toolkit with self-contained dataset fetching and direct topic interfaces.

scikit_tools-0.1.1/pyproject.toml

@@ -1,29 +0,0 @@
-[build-system]
-requires = ["setuptools>=61.0"]
-build-backend = "setuptools.build_meta"
-
-[project]
-name = "scikit-tools"
-version = "0.1.1"
-description = "Clean, dependency-managed toolkit with fully self-contained topic functions"
-authors = [
-  { name="Your Name", email="your.email@example.com" }
-]
-readme = "README.md"
-requires-python = ">=3.8"
-classifiers = [
-    "Programming Language :: Python :: 3",
-    "License :: OSI Approved :: MIT License",
-    "Operating System :: OS Independent",
-]
-dependencies = [
-    "pandas",
-    "numpy",
-    "matplotlib",
-    "seaborn",
-    "scipy",
-    "scikit-learn"
-]
-
-[tool.setuptools.packages.find]
-where = ["src"]

scikit_tools-0.1.1/src/scikit_tools/__init__.py

@@ -1 +0,0 @@
-from .solutions import *

scikit_tools-0.1.1/src/scikit_tools/solutions.py

@@ -1,205 +0,0 @@
-def ensure_dataset(filepath='iris.csv'):
-    """Ensures that the local dataset exists. If not, automatically downloads and formats it."""
-    import os
-    import pandas as pd
-    if not os.path.exists(filepath):
-        url = 'https://raw.githubusercontent.com/mwaskom/seaborn-data/master/iris.csv'
-        df = pd.read_csv(url)
-        df.columns = ['SepalLengthCm', 'SepalWidthCm', 'PetalLengthCm', 'PetalWidthCm', 'Species']
-        df['Species'] = df['Species'].map(lambda x: f"Iris-{x}")
-        df.to_csv(filepath, index=False)
-
-def numpy_stats(filepath='iris.csv'):
-    """Topic 1: Basic numerical operations and statistics using NumPy."""
-    import pandas as pd
-    import numpy as np
-    ensure_dataset(filepath)
-    df = pd.read_csv(filepath)
-    sepal_length = df['SepalLengthCm'].to_numpy()
-    return {
-        'sum': np.sum(sepal_length),
-        'mean': np.mean(sepal_length),
-        'max': np.max(sepal_length),
-        'min': np.min(sepal_length),
-        'first_five': sepal_length[:5]
-    }
-
-def inspect_dataset(filepath='iris.csv'):
-    """Topic 2: Load DataFrame and inspect its structure, columns, and shape."""
-    import pandas as pd
-    ensure_dataset(filepath)
-    df = pd.read_csv(filepath)
-    return {
-        'head': df.head(),
-        'shape': df.shape,
-        'dtypes': df.dtypes,
-        'description': df.describe()
-    }
-
-def handle_missing_values(filepath='iris.csv'):
-    """Topic 3: Introduce mock missing values and handle them using median and mode."""
-    import pandas as pd
-    import numpy as np
-    ensure_dataset(filepath)
-    df_copy = pd.read_csv(filepath).copy()
-    df_copy.loc[[5, 10, 15], 'SepalLengthCm'] = np.nan
-    df_copy.loc[[20, 25], 'Species'] = np.nan
-
-    median_sepal = df_copy['SepalLengthCm'].median()
-    df_copy['SepalLengthCm'] = df_copy['SepalLengthCm'].fillna(median_sepal)
-    mode_species = df_copy['Species'].mode()[0]
-    df_copy['Species'] = df_copy['Species'].fillna(mode_species)
-    return df_copy
-
-def data_transformation(filepath='iris.csv'):
-    """Topic 4: Perform one-hot encoding and standardization (scaling)."""
-    import pandas as pd
-    from sklearn.preprocessing import StandardScaler
-    ensure_dataset(filepath)
-    df = pd.read_csv(filepath)
-    df_encoded = pd.get_dummies(df, columns=['Species'])
-    num_cols = ['SepalLengthCm', 'SepalWidthCm', 'PetalLengthCm', 'PetalWidthCm']
-    scaler = StandardScaler()
-    df_encoded[num_cols] = scaler.fit_transform(df_encoded[num_cols])
-    return df_encoded
-
-def eda_plots(filepath='iris.csv'):
-    """Topic 5: Generate and render Histogram and Scatter Plots for EDA."""
-    import pandas as pd
-    import matplotlib.pyplot as plt
-    import seaborn as sns
-    ensure_dataset(filepath)
-    df = pd.read_csv(filepath)
-    fig, axes = plt.subplots(1, 2, figsize=(14, 5))
-    sns.histplot(data=df, x='PetalLengthCm', kde=True, color='skyblue', ax=axes[0])
-    axes[0].set_title('Histogram of PetalLengthCm')
-    sns.scatterplot(data=df, x='SepalLengthCm', y='PetalLengthCm', hue='Species', palette='Set1', ax=axes[1])
-    axes[1].set_title('SepalLengthCm vs PetalLengthCm')
-    plt.tight_layout()
-    plt.show()
-
-def outlier_detection(filepath='iris.csv'):
-    """Topic 6: Quantify outliers using Interquartile Range (IQR) bounds."""
-    import pandas as pd
-    ensure_dataset(filepath)
-    df = pd.read_csv(filepath)
-    Q1 = df['SepalWidthCm'].quantile(0.25)
-    Q3 = df['SepalWidthCm'].quantile(0.75)
-    IQR = Q3 - Q1
-    lower_bound = Q1 - 1.5 * IQR
-    upper_bound = Q3 + 1.5 * IQR
-    outliers = df[(df['SepalWidthCm'] < lower_bound) | (df['SepalWidthCm'] > upper_bound)]
-    return {
-        'IQR': IQR,
-        'limits': (lower_bound, upper_bound),
-        'outliers': outliers
-    }
-
-def descriptive_stats(filepath='iris.csv'):
-    """Topic 7: Calculate detailed descriptive metrics."""
-    import pandas as pd
-    ensure_dataset(filepath)
-    df = pd.read_csv(filepath)
-    attributes = ['SepalLengthCm', 'PetalLengthCm']
-    return pd.DataFrame({
-        'Mean': df[attributes].mean(),
-        'Median': df[attributes].median(),
-        'Sample Variance': df[attributes].var(),
-        'Standard Deviation': df[attributes].std()
-    })
-
-def correlation_covariance(filepath='iris.csv'):
-    """Topic 8: Evaluate covariance and Pearson correlation coefficient."""
-    import pandas as pd
-    ensure_dataset(filepath)
-    df = pd.read_csv(filepath)
-    return {
-        'covariance': df['PetalLengthCm'].cov(df['PetalWidthCm']),
-        'correlation': df['PetalLengthCm'].corr(df['PetalWidthCm'])
-    }
-
-def hypothesis_testing(filepath='iris.csv'):
-    """Topic 9: Run an independent T-test on SepalLengthCm between Setosa and Versicolor."""
-    import pandas as pd
-    from scipy import stats
-    ensure_dataset(filepath)
-    df = pd.read_csv(filepath)
-    setosa_sepal = df[df['Species'] == 'Iris-setosa']['SepalLengthCm']
-    versicolor_sepal = df[df['Species'] == 'Iris-versicolor']['SepalLengthCm']
-    t_stat, p_val = stats.ttest_ind(setosa_sepal, versicolor_sepal, equal_var=False)
-    return {'t_statistic': t_stat, 'p_value': p_val}
-
-def linear_regression(filepath='iris.csv'):
-    """Topic 10: Linear Regression predicting PetalLengthCm."""
-    import pandas as pd
-    from sklearn.model_selection import train_test_split
-    from sklearn.linear_model import LinearRegression
-    ensure_dataset(filepath)
-    df = pd.read_csv(filepath)
-    X = df[['SepalLengthCm', 'SepalWidthCm', 'PetalWidthCm']]
-    y = df['PetalLengthCm']
-    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
-    model = LinearRegression()
-    model.fit(X_train, y_train)
-    predictions = model.predict(X_test)
-    return {
-        'coefficients': {col: coef for col, coef in zip(X.columns, model.coef_)},
-        'intercept': model.intercept_,
-        'predictions': pd.DataFrame({'Actual': y_test, 'Predicted': predictions})
-    }
-
-def logistic_regression(filepath='iris.csv'):
-    """Topic 11: Multi-class Logistic Regression for classification."""
-    import pandas as pd
-    from sklearn.model_selection import train_test_split
-    from sklearn.linear_model import LogisticRegression
-    from sklearn.metrics import accuracy_score, confusion_matrix
-    ensure_dataset(filepath)
-    df = pd.read_csv(filepath)
-    X = df[['SepalLengthCm', 'SepalWidthCm', 'PetalLengthCm', 'PetalWidthCm']]
-    y = df['Species']
-    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
-    clf = LogisticRegression(max_iter=200)
-    clf.fit(X_train, y_train)
-    y_pred = clf.predict(X_test)
-    return {
-        'accuracy': accuracy_score(y_test, y_pred),
-        'confusion_matrix': confusion_matrix(y_test, y_pred)
-    }
-
-def kmeans_clustering(filepath='iris.csv'):
-    """Topic 12: Cluster attributes unsupervised using K-Means."""
-    import pandas as pd
-    from sklearn.cluster import KMeans
-    ensure_dataset(filepath)
-    df = pd.read_csv(filepath)
-    X = df[['SepalLengthCm', 'SepalWidthCm', 'PetalLengthCm', 'PetalWidthCm']]
-    kmeans = KMeans(n_clusters=3, random_state=42, n_init='auto')
-    df['Cluster'] = kmeans.fit_predict(X)
-    return df
-
-def pca_analysis(filepath='iris.csv'):
-    """Topic 13: Standardize, compress with 2-Component PCA, and classify."""
-    import pandas as pd
-    from sklearn.preprocessing import StandardScaler
-    from sklearn.decomposition import PCA
-    from sklearn.model_selection import train_test_split
-    from sklearn.linear_model import LogisticRegression
-    from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score
-    ensure_dataset(filepath)
-    df = pd.read_csv(filepath)
-    X = df[['SepalLengthCm', 'SepalWidthCm', 'PetalLengthCm', 'PetalWidthCm']]
-    y = df['Species']
-    X_scaled = StandardScaler().fit_transform(X)
-    pca = PCA(n_components=2)
-    X_pca = pca.fit_transform(X_scaled)
-    X_train, X_test, y_train, y_test = train_test_split(X_pca, y, test_size=0.2, random_state=42)
-    clf = LogisticRegression()
-    clf.fit(X_train, y_train)
-    y_pred = clf.predict(X_test)
-    return {
-        'accuracy': accuracy_score(y_test, y_pred),
-        'precision': precision_score(y_test, y_pred, average='macro'),
-        'recall': recall_score(y_test, y_pred, average='macro'),
-        'f1_score': f1_score(y_test, y_pred, average='macro')
-    }

scikit_tools-0.1.1/src/scikit_tools.egg-info/PKG-INFO

@@ -1,19 +0,0 @@
-Metadata-Version: 2.4
-Name: scikit-tools
-Version: 0.1.1
-Summary: Clean, dependency-managed toolkit with fully self-contained topic functions
-Author-email: Your Name <your.email@example.com>
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-Requires-Dist: pandas
-Requires-Dist: numpy
-Requires-Dist: matplotlib
-Requires-Dist: seaborn
-Requires-Dist: scipy
-Requires-Dist: scikit-learn
-
-# scikit-tools
-A clean, streamlined scientific data science toolkit with self-contained dataset fetching and direct topic interfaces.

scikit_tools-0.1.1/src/scikit_tools.egg-info/SOURCES.txt

@@ -1,9 +0,0 @@
-README.md
-pyproject.toml
-src/scikit_tools/__init__.py
-src/scikit_tools/solutions.py
-src/scikit_tools.egg-info/PKG-INFO
-src/scikit_tools.egg-info/SOURCES.txt
-src/scikit_tools.egg-info/dependency_links.txt
-src/scikit_tools.egg-info/requires.txt
-src/scikit_tools.egg-info/top_level.txt