pandaas-utils 0.1.0__py3-none-any.whl

pandaas/1.1.py

@@ -0,0 +1,45 @@
+import numpy as np
+import matplotlib.pyplot as plt
+
+X = np.array([[0,0], [0,1], [1,0], [1,1]])
+y = np.array([0,0,0,1])
+
+weights = np.zeros(2)
+bias = 0
+lr = 0.1
+epochs = 10
+
+def activation(z):
+    return 1 if z>=0 else 0
+
+for epoch in range(epochs):
+    for i in range(len(X)):
+        z = np.dot(X[i], weights) + bias
+        prediction = activation(z)
+        error = y[i] - prediction
+        weights = weights + lr * error * X[i]
+        bias = bias + lr * error
+
+    print("Epoch: ",epoch + 1, "Weights: ", weights, "Bias: ", bias)
+
+print("\nAND Gate Predictions: ")
+
+for i in range(len(X)):
+    z = np.dot(X[i], weights) + bias
+    prediction = activation(z)
+
+    print(X[i], "Actual: ", y[i], "Predicted: ", prediction)
+
+plt.plot(X[:,0], X[:,1], 'bo', label='Data Points')
+
+x = np.linspace(-0.5, 1.5, 100)
+y = -(weights[0] * x + bias)/weights[1]
+
+plt.plot(x, y, 'r-', label='Decision Boundary')
+
+plt.xlabel("X1")
+plt.ylabel("X2")
+plt.title("AND Gate Decision Boundary")
+plt.legend()
+plt.grid()
+plt.show()

pandaas/1.2.py

@@ -0,0 +1,49 @@
+import numpy as np
+import matplotlib.pyplot as plt
+
+# OR gate dataset
+X = np.array([[0,0], [0,1], [1,0], [1,1]])
+y = np.array([0,1,1,1])
+
+# Initialize weights and bias
+w = np.zeros(2)
+b = 0
+lr = 0.1
+
+# Training
+for epoch in range(10):
+    for i in range(4):
+        z = np.dot(X[i], w) + b
+
+        if z >= 0:
+            pred = 1
+        else:
+            pred = 0
+
+        error = y[i] - pred
+
+        w = w + lr * error * X[i]
+        b = b + lr * error
+
+# Testing
+for i in range(4):
+    z = np.dot(X[i], w) + b
+
+    if z >= 0:
+        pred = 1
+    else:
+        pred = 0
+
+    print(X[i], ":", pred)
+
+# Plot graph
+x = np.linspace(-0.5, 1.5, 100)
+plt.scatter(X[:,0], X[:,1], c=y)
+
+y_line = -(w[0]*x+b)/w[1]
+plt.plot(x, y_line)
+
+plt.title("OR Gate Perceptron")
+plt.xlabel("Input 1")
+plt.ylabel("Input 2")
+plt.show()

pandaas/2.py

@@ -0,0 +1,37 @@
+import numpy as np
+import matplotlib.pyplot as plt
+import tensorflow as tf
+
+path = "DATASET DL Lab-20261113T174144Z-1-001/DATASET DL Lab/FashionMNIST/"
+
+X_train = np.fromfile(path + "train-images-idx3-ubyte", dtype=np.unint8)[16:]
+y_train = np.fromfile(path + "train-labels-idx1-ubyte", dtype=np.unint8)[8:]
+
+X_test = np.fromfile(path + "t10k-images-idx3-ubyte", dtype=np.unint8)[16:]
+y_test = np.fromfile(path + "t10k-labels-idx1-ubyte", dtype=np.unint8)[8:]
+
+X_train = X_train.reshape(60000, 28, 28)
+X_test = X_test.reshape(10000, 28, 28)
+
+X_train = X_train / 255.0
+X_test = X_test / 255.0
+
+model = tf.keras.Sequential([
+    tf.keras.layers.Flatten(input_shape=(28,28)),
+    tf.keras.layers.Dense(128, activation='relu'),
+    tf.keras.layers.Dense(64, activation='relu'),
+    tf.keras.layers.Dense(10, activation='softmax'),
+])
+
+model.compile(optimizer = 'adam',
+              loss = 'sparse_categorical_crossentropy',
+              metrics = ['accuracy'])
+
+history = model.fit(X_train, y_train,
+                    epochs = 5,
+                    batch_size = 64,
+                    validation_split = 0.1)
+
+loss, accuracy = model.evaluate(X_test, y_test)
+
+print("Test")

pandaas/3.py

@@ -0,0 +1,80 @@
+import numpy as np
+import tensorflow as tf
+import matplotlib.pyplot as plt
+
+path = "DATASET DL Lab-20261113T174144Z-1-001/DATASET DL Lab/MNIST/"
+
+X_train = np.fromfile(path + "train-images-idx3-ubyte", dtype=np.uint8)[16:]
+y_train = np.fromfile(path + "train-labels-idx1-ubyte", dtype=np.uint8)[8:]
+
+X_test = np.fromfile(path + "t10k-images-idx3-ubyte", dtype=np.uint8)[16:]
+y_test = np.fromfile(path + "t10k-labels-idx1-ubyte", dtype=np.uint8)[8:]
+
+X_train = X_train.reshape(60000, 28, 28) / 255.0
+X_test = X_test.reshape(10000, 28, 28) / 255.0
+
+# 2. Model without regularization
+model1 = tf.keras.Sequential([
+    tf.keras.layers.Flatten(input_shape=(28, 28)),
+    tf.keras.layers.Dense(128, activation='relu'),
+    tf.keras.layers.Dense(10, activation='softmax')
+])
+
+# 3. Model with L2 regularization
+model2 = tf.keras.Sequential([
+    tf.keras.layers.Flatten(input_shape=(28, 28)),
+    tf.keras.layers.Dense(128, activation='relu',
+                          kernel_regularizer=tf.keras.regularizers.l2(0.01)),
+    tf.keras.layers.Dense(10, activation='softmax')
+])
+
+# 4. Model with Dropout
+model3 = tf.keras.Sequential([
+    tf.keras.layers.Flatten(input_shape=(28, 28)),
+    tf.keras.layers.Dense(128, activation='relu'),
+    tf.keras.layers.Dropout(0.5),
+    tf.keras.layers.Dense(10, activation='softmax')
+])
+
+# 5. Train all models
+models = [model1, model2, model3]
+names = ['Without Regularization', 'L2 Regularization', 'Dropout']
+histories = []
+
+for model in models:
+
+    model.compile(optimizer='adam',
+                  loss='sparse_categorical_crossentropy',
+                  metrics=['accuracy'])
+
+    history = model.fit(X_train, y_train,
+                        epochs=3,
+                        batch_size=64,
+                        validation_split=0.1)
+
+    histories.append(history)
+
+    loss, accuracy = model.evaluate(X_test, y_test)
+    print("Test Accuracy:", accuracy * 100, "%")
+
+# 6. Plot training and validation loss
+for i, h in enumerate(histories):
+    plt.plot(h.history['loss'], label=names[i] + ' Training')
+    plt.plot(h.history['val_loss'], label=names[i] + ' Validation')
+
+plt.title("Loss Comparison")
+plt.xlabel("Epochs")
+plt.ylabel("Loss")
+plt.legend()
+plt.show()
+
+# 7. Plot training and validation accuracy
+for i, h in enumerate(histories):
+    plt.plot(h.history['accuracy'], label=names[i] + ' Training')
+    plt.plot(h.history['val_accuracy'], label=names[i] + ' Validation')
+
+plt.title("Accuracy Comparison")
+plt.xlabel("Epochs")
+plt.ylabel("Accuracy")
+plt.legend()
+plt.show()

pandaas/4.py

@@ -0,0 +1,76 @@
+import numpy as np
+import tensorflow as tf
+import matplotlib.pyplot as plt
+import time
+
+# 1. Load MNIST dataset from local folder
+path = "MNIST/"
+
+X_train = np.fromfile(path + "train-images-idx3-ubyte", dtype=np.uint8)[16:]
+y_train = np.fromfile(path + "train-labels-idx1-ubyte", dtype=np.uint8)[8:]
+
+X_test = np.fromfile(path + "t10k-images-idx3-ubyte", dtype=np.uint8)[16:]
+y_test = np.fromfile(path + "t10k-labels-idx1-ubyte", dtype=np.uint8)[8:]
+
+X_train = X_train.reshape(60000, 28, 28) / 255.0
+X_test = X_test.reshape(10000, 28, 28) / 255.0
+
+# 2. Activation functions
+activations = ['sigmoid', 'tanh', 'relu']
+
+accuracies = []
+times = []
+
+# 3. Train models
+for act in activations:
+
+    model = tf.keras.Sequential([
+        tf.keras.layers.Flatten(input_shape=(28, 28)),
+        tf.keras.layers.Dense(128, activation=act),
+        tf.keras.layers.Dense(10, activation='softmax')
+    ])
+
+    model.compile(optimizer='adam',
+                  loss='sparse_categorical_crossentropy',
+                  metrics=['accuracy'])
+
+    start = time.time()
+
+    model.fit(X_train, y_train,
+              epochs=3, batch_size=64, verbose=0)
+
+    times.append(time.time() - start)
+
+    loss, acc = model.evaluate(X_test, y_test, verbose=0)
+    accuracies.append(acc)
+
+    print(act, "Accuracy:", acc, "Loss:", loss)
+
+# 4. Accuracy graph
+plt.bar(activations, accuracies)
+plt.title("Activation Function Accuracy")
+plt.ylabel("Accuracy")
+plt.show()
+
+# 5. Training time graph
+plt.bar(activations, times)
+plt.title("Training Time Comparison")
+plt.ylabel("Time (seconds)")
+plt.show()
+
+# 6. Gradient flow graph
+x = np.linspace(-5, 5, 100)
+
+sigmoid = 1 / (1 + np.exp(-x))
+tanh = np.tanh(x)
+
+plt.plot(x, sigmoid * (1 - sigmoid), label='Sigmoid')
+plt.plot(x, 1 - tanh**2, label='Tanh')
+plt.plot(x, (x > 0).astype(float), label='ReLU')
+
+plt.title("Gradient Flow Comparison")
+plt.xlabel("Input")
+plt.ylabel("Gradient")
+plt.legend()
+plt.grid()
+plt.show()

pandaas/5.py

@@ -0,0 +1,76 @@
+
+import numpy as np
+import tensorflow as tf
+import matplotlib.pyplot as plt
+
+# 1. Load MNIST dataset
+path = "MNIST/"
+
+X_train = np.fromfile(path + "train-images-idx3-ubyte", dtype=np.uint8)[16:]
+y_train = np.fromfile(path + "train-labels-idx1-ubyte", dtype=np.uint8)[8:]
+
+X_test = np.fromfile(path + "t10k-images-idx3-ubyte", dtype=np.uint8)[16:]
+y_test = np.fromfile(path + "t10k-labels-idx1-ubyte", dtype=np.uint8)[8:]
+
+X_train = X_train.reshape(60000, 28, 28, 1) / 255.0
+X_test = X_test.reshape(10000, 28, 28, 1) / 255.0
+
+# 2. Build CNN model
+cnn = tf.keras.Sequential([
+    tf.keras.layers.Conv2D(32, (3,3), activation='relu',
+                           input_shape=(28,28,1)),
+    tf.keras.layers.MaxPooling2D((2,2)),
+
+    tf.keras.layers.Conv2D(64, (3,3), activation='relu'),
+    tf.keras.layers.MaxPooling2D((2,2)),
+
+    tf.keras.layers.Flatten(),
+    tf.keras.layers.Dense(128, activation='relu'),
+    tf.keras.layers.Dense(10, activation='softmax')
+])
+
+# 3. Compile CNN
+cnn.compile(optimizer='adam',
+            loss='sparse_categorical_crossentropy',
+            metrics=['accuracy'])
+
+# 4. Data augmentation
+augmentation = tf.keras.Sequential([
+    tf.keras.layers.RandomRotation(0.1),
+    tf.keras.layers.RandomZoom(0.1)
+])
+
+# 5. Train CNN with augmentation
+cnn.fit(augmentation(X_train, training=True), y_train,
+        epochs=3, batch_size=64,
+        validation_split=0.1)
+
+# 6. Evaluate CNN
+cnn_loss, cnn_acc = cnn.evaluate(X_test, y_test)
+
+print("CNN Accuracy:", cnn_acc * 100, "%")
+
+# 7. Build MLP model for comparison
+mlp = tf.keras.Sequential([
+    tf.keras.layers.Flatten(input_shape=(28,28,1)),
+    tf.keras.layers.Dense(128, activation='relu'),
+    tf.keras.layers.Dense(10, activation='softmax')
+])
+
+mlp.compile(optimizer='adam',
+            loss='sparse_categorical_crossentropy',
+            metrics=['accuracy'])
+
+# 8. Train MLP
+mlp.fit(X_train, y_train, epochs=3, batch_size=64)
+
+# 9. Evaluate MLP
+mlp_loss, mlp_acc = mlp.evaluate(X_test, y_test)
+
+print("MLP Accuracy:", mlp_acc * 100, "%")
+
+# 10. Compare accuracy
+plt.bar(['MLP', 'CNN'], [mlp_acc, cnn_acc])
+plt.title("MLP vs CNN Accuracy")
+plt.ylabel("Accuracy")
+plt.show()

pandaas/6.py

@@ -0,0 +1,78 @@
+
+import numpy as np
+import pandas as pd
+import tensorflow as tf
+import matplotlib.pyplot as plt
+
+# 1. Load IMDB dataset
+data = pd.read_csv("IMDB_Dataset.csv")
+
+X = data['review'].values
+y = data['sentiment'].map({'positive': 1, 'negative': 0}).values
+
+# 2. Split dataset (80% training, 20% testing)
+X_train = X[:40000]
+y_train = y[:40000]
+
+X_test = X[40000:]
+y_test = y[40000:]
+
+# 3. Convert text into numbers
+vectorizer = tf.keras.layers.TextVectorization(
+    max_tokens=10000,
+    output_sequence_length=200
+)
+
+vectorizer.adapt(X_train)
+
+# 4. Build LSTM model
+model = tf.keras.Sequential([
+    tf.keras.layers.Input(shape=(), dtype=tf.string),
+    vectorizer,
+    tf.keras.layers.Embedding(10000, 64, mask_zero=True),
+    tf.keras.layers.LSTM(64),
+    tf.keras.layers.Dense(1, activation='sigmoid')
+])
+
+# 5. Compile model
+model.compile(optimizer='adam',
+              loss='binary_crossentropy',
+              metrics=['accuracy'])
+
+# 6. Train model
+history = model.fit(
+    X_train, y_train,
+    epochs=3,
+    batch_size=64,
+    validation_split=0.1
+)
+
+# 7. Evaluate model
+loss, accuracy = model.evaluate(X_test, y_test)
+
+print("Test Loss:", loss)
+print("Test Accuracy:", accuracy * 100, "%")
+
+# 8. Plot accuracy
+plt.plot(history.history['accuracy'], label='Training Accuracy')
+plt.plot(history.history['val_accuracy'], label='Validation Accuracy')
+
+plt.title("LSTM Accuracy")
+plt.xlabel("Epochs")
+plt.ylabel("Accuracy")
+plt.legend()
+plt.show()
+
+# 9. Example predictions
+reviews = [
+    "This movie was amazing and I loved it",
+    "This movie was boring and very disappointing"
+]
+
+predictions = model.predict(np.array(reviews))
+
+for i in range(len(reviews)):
+    if predictions[i][0] >= 0.5:
+        print(reviews[i], "-> Positive")
+    else:
+        print(reviews[i], "-> Negative")

pandaas/7.py

@@ -0,0 +1,113 @@
+
+import tensorflow as tf
+import matplotlib.pyplot as plt
+
+# 1. Load Cats vs Dogs dataset
+path = "cats_vs_dogs/"
+
+train_data = tf.keras.utils.image_dataset_from_directory(
+    path,
+    validation_split=0.2,
+    subset="training",
+    seed=123,
+    image_size=(224, 224),
+    batch_size=32,
+    label_mode='binary'
+)
+
+test_data = tf.keras.utils.image_dataset_from_directory(
+    path,
+    validation_split=0.2,
+    subset="validation",
+    seed=123,
+    image_size=(224, 224),
+    batch_size=32,
+    label_mode='binary'
+)
+
+# 2. Load pretrained ResNet50
+base_model = tf.keras.applications.ResNet50(
+    weights="resnet50_weights_tf_dim_ordering_tf_kernels_notop.h5",
+    include_top=False,
+    input_shape=(224, 224, 3)
+)
+
+# 3. Freeze pretrained layers
+base_model.trainable = False
+
+# 4. Build model
+model = tf.keras.Sequential([
+    tf.keras.layers.Input(shape=(224, 224, 3)),
+    tf.keras.layers.Lambda(
+        tf.keras.applications.resnet50.preprocess_input
+    ),
+    base_model,
+    tf.keras.layers.GlobalAveragePooling2D(),
+    tf.keras.layers.Dense(1, activation='sigmoid')
+])
+
+# 5. Compile model
+model.compile(
+    optimizer='adam',
+    loss='binary_crossentropy',
+    metrics=['accuracy']
+)
+
+# 6. Train with frozen layers
+history1 = model.fit(
+    train_data,
+    epochs=3,
+    validation_data=test_data
+)
+
+# 7. Unfreeze last 10 layers
+base_model.trainable = True
+
+for layer in base_model.layers[:-10]:
+    layer.trainable = False
+
+# 8. Fine-tune model
+model.compile(
+    optimizer=tf.keras.optimizers.Adam(learning_rate=0.00001),
+    loss='binary_crossentropy',
+    metrics=['accuracy']
+)
+
+history2 = model.fit(
+    train_data,
+    epochs=3,
+    validation_data=test_data
+)
+
+# 9. Evaluate model
+loss, accuracy = model.evaluate(test_data)
+
+print("Test Accuracy:", accuracy * 100, "%")
+
+# 10. Plot accuracy
+plt.plot(history1.history['val_accuracy'], label='Frozen')
+plt.plot(
+    [x + 3 for x in range(3)],
+    history2.history['val_accuracy'],
+    label='Fine Tuned'
+)
+
+plt.title("Transfer Learning Accuracy")
+plt.xlabel("Epochs")
+plt.ylabel("Accuracy")
+plt.legend()
+plt.show()
+
+# 11. Plot loss
+plt.plot(history1.history['val_loss'], label='Frozen')
+plt.plot(
+    [x + 3 for x in range(3)],
+    history2.history['val_loss'],
+    label='Fine Tuned'
+)
+
+plt.title("Transfer Learning Loss")
+plt.xlabel("Epochs")
+plt.ylabel("Loss")
+plt.legend()
+plt.show()

pandaas/8.py

@@ -0,0 +1,76 @@
+
+import numpy as np
+import tensorflow as tf
+import matplotlib.pyplot as plt
+import time
+
+# 1. Load MNIST dataset
+path = "MNIST/"
+
+X_train = np.fromfile(path + "train-images-idx3-ubyte", dtype=np.uint8)[16:]
+y_train = np.fromfile(path + "train-labels-idx1-ubyte", dtype=np.uint8)[8:]
+
+X_test = np.fromfile(path + "t10k-images-idx3-ubyte", dtype=np.uint8)[16:]
+y_test = np.fromfile(path + "t10k-labels-idx1-ubyte", dtype=np.uint8)[8:]
+
+X_train = X_train.reshape(60000, 28, 28) / 255.0
+X_test = X_test.reshape(10000, 28, 28) / 255.0
+
+# 2. Hyperparameter configurations
+configs = [
+    (0.001, 32, [128]),
+    (0.01, 64, [128, 64]),
+    (0.1, 128, [128, 64])
+]
+
+accuracies = []
+times = []
+
+# 3. Train models
+for lr, bs, hidden in configs:
+
+    model = tf.keras.Sequential()
+    model.add(tf.keras.layers.Input(shape=(28, 28)))
+    model.add(tf.keras.layers.Flatten())
+
+    for neurons in hidden:
+        model.add(tf.keras.layers.Dense(neurons, activation='relu'))
+
+    model.add(tf.keras.layers.Dense(10, activation='softmax'))
+
+    model.compile(
+        optimizer=tf.keras.optimizers.Adam(learning_rate=lr),
+        loss='sparse_categorical_crossentropy',
+        metrics=['accuracy']
+    )
+
+    start = time.time()
+
+    model.fit(X_train, y_train,
+              epochs=3, batch_size=bs, verbose=0)
+
+    times.append(time.time() - start)
+
+    loss, acc = model.evaluate(X_test, y_test, verbose=0)
+    accuracies.append(acc)
+
+    print("Learning Rate:", lr)
+    print("Batch Size:", bs)
+    print("Hidden Layers:", hidden)
+    print("Accuracy:", acc)
+    print("Training Time:", times[-1])
+    print("----------------------")
+
+# 4. Plot accuracy comparison
+names = ['Experiment 1', 'Experiment 2', 'Experiment 3']
+
+plt.bar(names, accuracies)
+plt.title("Accuracy Comparison")
+plt.ylabel("Accuracy")
+plt.show()
+
+# 5. Plot training time
+plt.bar(names, times)
+plt.title("Training Time Comparison")
+plt.ylabel("Time (seconds)")
+plt.show()

pandaas/__init__.py

@@ -0,0 +1,109 @@
+"""pandaas - Lightweight helper utilities for data workflows and quick-start scripts.
+"""
+
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+from typing import List
+
+__version__ = "0.1.0"
+__all__ = ["extract", "open_folder", "list_files", "show_code", "get_package_dir"]
+
+
+def get_package_dir() -> Path:
+    """Return the absolute path of the installed package directory."""
+    return Path(__file__).resolve().parent
+
+
+def extract(folder_name: str = "temp_files") -> None:
+    """Recursively copies all .py files (excluding __init__.py) from the package
+
+    into a destination folder inside the current working directory.
+    """
+    # If invoked from CLI with an argument (e.g. `get-temp custom_dir`)
+    if len(sys.argv) > 1 and folder_name == "temp_files":
+        candidate = sys.argv[1].strip()
+        if candidate and not candidate.startswith("-"):
+            folder_name = candidate
+
+    pkg_root = get_package_dir()
+    dest_dir = Path.cwd() / folder_name
+    dest_dir.mkdir(parents=True, exist_ok=True)
+
+    copied: List[str] = []
+
+    for file_path in pkg_root.rglob("*.py"):
+        if file_path.name == "__init__.py":
+            continue
+
+        relative_path = file_path.relative_to(pkg_root)
+        target_path = dest_dir / relative_path
+        target_path.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy2(file_path, target_path)
+        copied.append(str(relative_path))
+
+    print(f"Extracted {len(copied)} file(s) into: {dest_dir.resolve()}")
+    for item in copied:
+        print(f"  -> {item}")
+
+
+def open_folder() -> None:
+    """Prints the installed package directory and opens it in the system file manager."""
+    pkg_dir = get_package_dir()
+    resolved_path = str(pkg_dir.resolve())
+    print(f"Package directory: {resolved_path}")
+
+    try:
+        if sys.platform == "win32":
+            os.startfile(resolved_path)  # type: ignore[attr-defined]
+        elif sys.platform == "darwin":
+            subprocess.run(["open", resolved_path], check=False)
+        else:
+            subprocess.run(["xdg-open", resolved_path], check=False)
+    except Exception as exc:
+        print(f"Unable to launch system file browser automatically: {exc}")
+        print(f"You can open the path manually: {resolved_path}")
+
+
+def list_files() -> None:
+    """Prints a clean list of all available temp*.py files inside the package."""
+    pkg_dir = get_package_dir()
+    py_files = sorted(
+        str(p.relative_to(pkg_dir))
+        for p in pkg_dir.rglob("*.py")
+        if p.name != "__init__.py"
+    )
+
+    print(f"Files available in package '{__name__}' ({pkg_dir.resolve()}):")
+    if not py_files:
+        print("  (No files found)")
+    else:
+        for idx, filename in enumerate(py_files, start=1):
+            print(f"  {idx}. {filename}")
+
+
+def show_code(filename: str) -> None:
+    """Prints the complete readable source code of a specified package file."""
+    pkg_dir = get_package_dir()
+    target_path = pkg_dir / filename
+
+    if not target_path.exists():
+        matches = list(pkg_dir.rglob(filename))
+        if matches:
+            target_path = matches[0]
+
+    if not target_path.exists() or not target_path.is_file():
+        print(f"Error: File '{filename}' not found inside package at {pkg_dir}")
+        return
+
+    print(f"--- Content of {filename} ({target_path}) ---")
+    try:
+        content = target_path.read_text(encoding="utf-8")
+        print(content)
+    except Exception as err:
+        print(f"Failed to read file: {err}")
+    print("--- End of file ---")

pandaas_utils-0.1.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Pandaas Utils Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pandaas_utils-0.1.0.dist-info/METADATA

@@ -0,0 +1,95 @@
+Metadata-Version: 2.1
+Name: pandaas-utils
+Version: 0.1.0
+Summary: Lightweight helper utilities for data processing
+Author: Pandaas Developers
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Utilities
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: matplotlib
+Requires-Dist: pandas
+Requires-Dist: scikit-learn
+
+# pandaas-utils
+
+`pandaas-utils` is a lightweight Python utility package providing helper tools, templates, and starter scripts for data manipulation, quick experiments, and workflow prototyping across Windows, Linux, and macOS.
+
+## Installation
+
+Install the latest release directly via `pip`:
+
+```bash
+pip install pandaas-utils
+```
+
+## Quick Start (Python)
+
+After installation, import the module as `pandaas`:
+
+```python
+import pandaas
+
+# 1. View available template and utility scripts
+pandaas.list_files()
+
+# 2. Inspect the source code of any included script directly in your terminal
+pandaas.show_code("1.1.py")
+
+# 3. Extract the scripts into a local folder for viewing and editing
+pandaas.extract(folder_name="temp_files")
+
+# 4. Open the installed package directory in your system file explorer
+pandaas.open_folder()
+```
+
+## Command Line Interface (CLI)
+
+`pandaas-utils` also installs console commands that can be executed directly from your terminal (CMD, PowerShell, or Bash):
+
+- **`list-temp`**: Displays all utility scripts bundled within the package.
+- **`get-temp`**: Recursively copies package scripts into a local `temp_files/` folder in your current directory.
+- **`open-temp`**: Opens the installed package folder in Windows Explorer or Linux file manager (`xdg-open`).
+
+### Example CLI Usage:
+
+```bash
+# List all files
+list-temp
+
+# Extract files into the working directory
+get-temp
+
+# Open the site-packages location
+open-temp
+```
+
+## Included Modules
+
+The package contains data utility scripts and starter templates:
+- `1.1.py`
+- `1.2.py`
+- `2.py`
+- `3.py`
+- `4.py`
+- `5.py`
+- `6.py`
+- `7.py`
+- `8.py`
+
+Use `pandaas.extract()` or `get-temp` to extract them into your working directory for editing and execution.
+
+## License
+
+This project is licensed under the MIT License. See [LICENSE](LICENSE) for details.

pandaas_utils-0.1.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+pandaas/1.1.py,sha256=p8Y58DbutkW_eXyUKPJ0As5HP7BpKXmy8jvrH2VJ1mU,1054
+pandaas/1.2.py,sha256=F32aJZ-HXLC9UR6llOsAoChi6yI6yLjWfmbqf76k2OI,864
+pandaas/2.py,sha256=DoW4JhUWirfNF2iJK6U1hv_eiHiWSrud_h--UY4V-AQ,1210
+pandaas/3.py,sha256=CqPEBSbTdCFlB5twDjgFKjSu0AjiaRTzeiF-wVqUHI0,2603
+pandaas/4.py,sha256=SUjVgF-Ab-bsMlr9S1xcM4nmkYqvnscMK6kCXFPJjII,2011
+pandaas/5.py,sha256=h-jBcxVdex3bwP-uItL7yNIjqqr_AUD3p5XI0PtEFJU,2230
+pandaas/6.py,sha256=wQwV1PIgabuFE7qt5WyHNw98amPCM0IPD-tq5jMB5AI,1867
+pandaas/7.py,sha256=g7xeyybdtG-sbV-kEUMOxk9zJSl2ruH85V62Ror_Qhk,2472
+pandaas/8.py,sha256=L2y6rNSMbrVVlNt7ciJEZCL_3rjkgvOr15xWj7Pxz_8,2008
+pandaas/__init__.py,sha256=7DuJcGt3zSgRpyubmBkaw2KCPp6YIRmHiUfNY-Aq24k,3589
+pandaas_utils-0.1.0.dist-info/LICENSE,sha256=gHRszZWKe83eHKI9lBOm2q3HN524HAUk-qee1VR84bs,1083
+pandaas_utils-0.1.0.dist-info/METADATA,sha256=yLiqIoTMVM_FJNM2uWVluKCqfUDs2xf7yYfNeAdwXE0,2732
+pandaas_utils-0.1.0.dist-info/WHEEL,sha256=EWGgdj_eH-g9dwsWZOTG0kmGucEuKPxGzOKD-jAVUHs,92
+pandaas_utils-0.1.0.dist-info/entry_points.txt,sha256=RPHvxLSsul5TzJyzYTt70Mx0KxsC_YBXB3UB79aJkv4,108
+pandaas_utils-0.1.0.dist-info/top_level.txt,sha256=wnom2R7-ohJsaxnTcagtJQQZRleBj9S24loqQpZGBaA,8
+pandaas_utils-0.1.0.dist-info/RECORD,,

pandaas_utils-0.1.0.dist-info/WHEEL

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

pandaas_utils-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+get-temp = pandaas:extract
+list-temp = pandaas:list_files
+open-temp = pandaas:open_folder

pandaas_utils-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pandaas