daup 0.1.0__tar.gz

daup-0.1.0/LICENSE

@@ -0,0 +1,17 @@
+MIT License
+
+Copyright (c) 2026 Daup maintainer
+
+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.

daup-0.1.0/PKG-INFO

@@ -0,0 +1,48 @@
+Metadata-Version: 2.4
+Name: daup
+Version: 0.1.0
+Summary: Download bundled Python practical scripts with simple functions
+Author: Daup maintainer
+License: MIT
+Keywords: python,scripts,education,download
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# daup
+
+A small Python package that copies bundled example scripts into your current directory.
+
+## Install
+
+```bash
+pip install daup
+```
+
+## Usage
+
+```python
+import daup
+
+daup.api()       # creates api.py in the current directory
+daup.bcan()      # creates bcan.py
+daup.cgi()       # creates cgi.py
+daup.data()      # creates data.py
+daup.db()        # creates db.py
+daup.dirty()     # creates dirty.py
+daup.iris()      # creates iris.py
+daup.pand()      # creates pand.py
+daup.wine()      # creates wine.py
+```
+
+Pass an optional destination directory:
+
+```python
+daup.api("downloads")
+```
+
+Each function returns the absolute path to the copied file. Existing files with the same name are overwritten.

daup-0.1.0/README.md

@@ -0,0 +1,33 @@
+# daup
+
+A small Python package that copies bundled example scripts into your current directory.
+
+## Install
+
+```bash
+pip install daup
+```
+
+## Usage
+
+```python
+import daup
+
+daup.api()       # creates api.py in the current directory
+daup.bcan()      # creates bcan.py
+daup.cgi()       # creates cgi.py
+daup.data()      # creates data.py
+daup.db()        # creates db.py
+daup.dirty()     # creates dirty.py
+daup.iris()      # creates iris.py
+daup.pand()      # creates pand.py
+daup.wine()      # creates wine.py
+```
+
+Pass an optional destination directory:
+
+```python
+daup.api("downloads")
+```
+
+Each function returns the absolute path to the copied file. Existing files with the same name are overwritten.

daup-0.1.0/daup/__init__.py

@@ -0,0 +1,68 @@
+"""Daup: download bundled Python example scripts to the current directory."""
+from pathlib import Path
+from importlib.resources import files
+
+__version__ = "0.1.0"
+
+_SCRIPT_NAMES = ("api", "bcan", "cgi", "data", "db", "dirty", "iris", "pand", "wine")
+
+
+def _download_script(name, destination="."):
+    """Copy a bundled script to destination and return its path."""
+    if name not in _SCRIPT_NAMES:
+        raise ValueError(f"Unknown script: {name}")
+    destination = Path(destination).expanduser()
+    destination.mkdir(parents=True, exist_ok=True)
+    output = destination / f"{name}.py"
+    source = files("daup").joinpath("_scripts", f"{name}.py")
+    output.write_bytes(source.read_bytes())
+    print(f"Downloaded {name}.py to {output.resolve()}")
+    return output.resolve()
+
+
+def api(destination="."):
+    """Download api.py to destination."""
+    return _download_script("api", destination)
+
+
+def bcan(destination="."):
+    """Download bcan.py to destination."""
+    return _download_script("bcan", destination)
+
+
+def cgi(destination="."):
+    """Download cgi.py to destination."""
+    return _download_script("cgi", destination)
+
+
+def data(destination="."):
+    """Download data.py to destination."""
+    return _download_script("data", destination)
+
+
+def db(destination="."):
+    """Download db.py to destination."""
+    return _download_script("db", destination)
+
+
+def dirty(destination="."):
+    """Download dirty.py to destination."""
+    return _download_script("dirty", destination)
+
+
+def iris(destination="."):
+    """Download iris.py to destination."""
+    return _download_script("iris", destination)
+
+
+def pand(destination="."):
+    """Download pand.py to destination."""
+    return _download_script("pand", destination)
+
+
+def wine(destination="."):
+    """Download wine.py to destination."""
+    return _download_script("wine", destination)
+
+
+__all__ = [*_SCRIPT_NAMES, "__version__"]

daup-0.1.0/daup/_scripts/api.py

@@ -0,0 +1,64 @@
+
+#Source Code
+import requests
+
+BASE_URL = "https://jsonplaceholder.typicode.com/posts"  # Mock REST API for reliable testing
+
+def check_status(response):
+    if response.status_code in [200, 201, 204]:
+        print(f"Status Code: {response.status_code} - Success")
+        return True
+    else:
+        print(f"Status Code: {response.status_code} - Failed")
+        return False
+
+def create_student(name, age, course):
+    payload = {"name": name, "age": age, "course": course}
+    res = requests.post(BASE_URL, json=payload)
+    print("Creating Student:", name)
+    if check_status(res):
+        data = res.json()
+        return data.get("id")
+    return None
+
+def get_all_students():
+    res = requests.get(BASE_URL)
+    print("Fetching All Students...")
+    if check_status(res):
+        return res.json()[:5]  # Limit output for display
+    return []
+
+def update_student(student_id, name, age, course):
+    url = f"{BASE_URL}/{student_id}"
+    payload = {"name": name, "age": age, "course": course}
+    res = requests.put(url, json=payload)
+    print(f"Updating Student ID {student_id}...")
+    check_status(res)
+
+def delete_student(student_id):
+    url = f"{BASE_URL}/{student_id}"
+    res = requests.delete(url)
+    print(f"Deleting Student ID {student_id}...")
+    check_status(res)
+
+def main():
+    id1 = create_student("Alice", 20, "CS")
+    id2 = create_student("Bob", 22, "IT")
+    id3 = create_student("Charlie", 21, "ECE")
+
+    print("\n--- All Students ---")
+    all_st = get_all_students()
+    print("Students Count:", len(all_st))
+
+    if id2:
+        update_student(id2, "Bob", 22, "Data Science")
+
+    if id1:
+        delete_student(id1)
+
+    print("\n--- Final Students List ---")
+    final_st = get_all_students()
+    print("Final List Count:", len(final_st))
+
+if __name__ == "__main__":
+    main()

daup-0.1.0/daup/_scripts/bcan.py

@@ -0,0 +1,148 @@
+import pandas as pd
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+from sklearn.datasets import load_breast_cancer
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import StandardScaler
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.tree import DecisionTreeClassifier
+from sklearn.linear_model import LogisticRegression
+from sklearn.metrics import accuracy_score, recall_score, confusion_matrix
+
+data = load_breast_cancer(as_frame=True)
+
+X = data.data
+y = data.target
+
+print("Dataset Shape:", X.shape)
+print("\nClass Distribution:")
+print(y.value_counts().rename(index={0: "Malignant", 1: "Benign"}))
+
+sns.countplot(x=y.map({0: "Malignant", 1: "Benign"}))
+plt.title("Class Distribution")
+plt.xlabel("Tumor Type")
+plt.show()
+
+plt.figure(figsize=(14, 10))
+sns.heatmap(X.corr(), cmap="coolwarm", center=0)
+plt.title("Feature Correlation Heatmap")
+plt.show()
+
+X_train, X_test, y_train, y_test = train_test_split(
+    X, y, test_size=0.2, random_state=42, stratify=y
+)
+
+scaler = StandardScaler()
+X_train_scaled = scaler.fit_transform(X_train)
+X_test_scaled = scaler.transform(X_test)
+
+rf_ranker = RandomForestClassifier(n_estimators=100, random_state=42)
+rf_ranker.fit(X_train, y_train)
+
+importance = pd.Series(
+    rf_ranker.feature_importances_,
+    index=X.columns
+).sort_values(ascending=False)
+
+print("\nFeature Ranking:")
+print(importance)
+
+plt.figure(figsize=(10, 6))
+importance.head(10).sort_values().plot(kind="barh")
+plt.title("Top 10 Features by Random Forest Importance")
+plt.xlabel("Importance")
+plt.show()
+
+top_features = importance.head(10).index.tolist()
+
+X_train_top = X_train[top_features]
+X_test_top = X_test[top_features]
+
+scaler_top = StandardScaler()
+X_train_top_scaled = scaler_top.fit_transform(X_train_top)
+X_test_top_scaled = scaler_top.transform(X_test_top)
+
+models = {
+    "Decision Tree": DecisionTreeClassifier(random_state=42),
+    "Random Forest": RandomForestClassifier(n_estimators=100, random_state=42),
+    "Logistic Regression": LogisticRegression(max_iter=1000)
+}
+
+results = []
+
+for name, model in models.items():
+    model.fit(X_train_scaled, y_train)
+    y_pred = model.predict(X_test_scaled)
+
+    results.append({
+        "Model": name,
+        "Features": "All 30",
+        "Accuracy": accuracy_score(y_test, y_pred),
+        "Malignant Recall": recall_score(y_test, y_pred, pos_label=0),
+        "False Negatives": confusion_matrix(y_test, y_pred, labels=[0, 1])[0, 1]
+    })
+
+for name, model in models.items():
+    model.fit(X_train_top_scaled, y_train)
+    y_pred = model.predict(X_test_top_scaled)
+
+    results.append({
+        "Model": name,
+        "Features": "Top 10",
+        "Accuracy": accuracy_score(y_test, y_pred),
+        "Malignant Recall": recall_score(y_test, y_pred, pos_label=0),
+        "False Negatives": confusion_matrix(y_test, y_pred, labels=[0, 1])[0, 1]
+    })
+
+results_df = pd.DataFrame(results)
+print("\nModel Comparison:")
+print(results_df)
+
+plt.figure(figsize=(10, 6))
+sns.barplot(data=results_df, x="Model", y="Accuracy", hue="Features")
+plt.title("Accuracy Before and After Feature Reduction")
+plt.ylim(0, 1)
+plt.show()
+
+plt.figure(figsize=(10, 6))
+sns.barplot(data=results_df, x="Model", y="Malignant Recall", hue="Features")
+plt.title("Malignant Recall Before and After Feature Reduction")
+plt.ylim(0, 1)
+plt.show()
+
+best_model_name = results_df.sort_values(
+    ["False Negatives", "Malignant Recall", "Accuracy"],
+    ascending=[True, False, False]
+).iloc[0]["Model"]
+
+print("\nModel with the fewest false negatives:")
+print(best_model_name)
+
+final_model = LogisticRegression(max_iter=1000)
+final_model.fit(X_train_scaled, y_train)
+
+y_pred = final_model.predict(X_test_scaled)
+
+cm = confusion_matrix(y_test, y_pred, labels=[0, 1])
+
+sns.heatmap(
+    cm,
+    annot=True,
+    fmt="d",
+    cmap="Blues",
+    xticklabels=["Malignant", "Benign"],
+    yticklabels=["Malignant", "Benign"]
+)
+plt.xlabel("Predicted")
+plt.ylabel("Actual")
+plt.title("Logistic Regression Confusion Matrix")
+plt.show()
+
+new_samples = X_test.iloc[:3]
+new_samples_scaled = scaler.transform(new_samples)
+predictions = final_model.predict(new_samples_scaled)
+
+print("\nPredictions for New Samples:")
+for i, prediction in enumerate(predictions):
+    print("Sample", i + 1, ":", data.target_names[prediction])

daup-0.1.0/daup/_scripts/cgi.py

@@ -0,0 +1,108 @@
+#sql + cgi
+#!/usr/bin/env python3
+import cgi
+import html
+import sqlite3
+
+print("Content-Type: text/html\n")
+conn = sqlite3.connect("cgi_demo.db")
+cur = conn.cursor()
+cur.execute("CREATE TABLE IF NOT EXISTS Users (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT)")
+conn.commit()
+
+form = cgi.FieldStorage()
+action = form.getvalue("action")
+if action == "insert":
+    name = form.getvalue("name")
+    if name:
+        cur.execute("INSERT INTO Users (name) VALUES (?)", (name,))
+        conn.commit()
+elif action == "update":
+    uid = form.getvalue("id")
+    name = form.getvalue("name")
+    if uid and name:
+        cur.execute("UPDATE Users SET name=? WHERE id=?", (name, uid))
+        conn.commit()
+elif action == "destroy":
+    uid = form.getvalue("id")
+    if uid:
+        cur.execute("DELETE FROM Users WHERE id=?", (uid,))
+        conn.commit()
+cur.execute("SELECT * FROM Users")
+rows = cur.fetchall()
+conn.close()
+
+print("""
+<html><body>
+<h2>CGI Database CRUD</h2>
+<form method="post">
+    Name: <input type="text" name="name"><br><br>
+    <button type="submit" name="action" value="insert">Insert</button>
+</form>
+<h3>Database Records:</h3>
+<table border="1" cellpadding="6">
+<tr><th>ID</th><th>Name</th><th>Actions</th></tr>
+""")
+for r in rows:
+    print(f"""
+<tr>
+    <td>{r[0]}</td>
+    <td>{html.escape(r[1])}</td>
+    <td>
+        <form method="post" style="display:inline">
+            <input type="hidden" name="id" value="{r[0]}">
+            <input type="text" name="name" value="{html.escape(r[1], quote=True)}">
+            <button type="submit" name="action" value="update">Edit</button>
+        </form>
+        <form method="post" style="display:inline">
+            <input type="hidden" name="id" value="{r[0]}">
+            <button type="submit" name="action" value="destroy">Delete</button>
+        </form>
+    </td>
+</tr>
+""")
+print("</table></body></html>")
+
+
+
+#MSC reg
+#!/usr/bin/env python3
+import cgi
+import html
+
+print("Content-Type: text/html\n")
+
+form = cgi.FieldStorage()
+
+name = form.getvalue("name")
+email = form.getvalue("email")
+degree = form.getvalue("degree")
+
+if name and email and degree:
+    print(f"""
+    <html>
+    <head><title>Registration Summary</title></head>
+    <body>
+        <h2>MSc Admission Registration Details</h2>
+        <p><b>Name:</b> {html.escape(name)}</p>
+        <p><b>Email:</b> {html.escape(email)}</p>
+        <p><b>Previous Degree:</b> {html.escape(degree)}</p>
+    </body>
+    </html>
+    """)
+else:
+    print("""
+    <html>
+    <head><title>MSc Admission Form</title></head>
+    <body>
+        <h2>MSc Admission Registration</h2>
+        <form method="post" action="q29.py">
+            Name: <input type="text" name="name"><br><br>
+            Email: <input type="email" name="email"><br><br>
+            Previous Degree: <input type="text" name="degree"><br><br>
+            <input type="submit" value="Register">
+        </form>
+    </body>
+    </html>
+    """)
+

daup-0.1.0/daup/_scripts/data.py

@@ -0,0 +1,54 @@
+import pandas as pd
+import seaborn as sns
+import matplotlib.pyplot as plt
+from sklearn.preprocessing import StandardScaler
+
+df = pd.read_csv("Data.csv")
+
+print("Original Dataset:")
+print(df.head())
+print("\nDataset Shape:", df.shape)
+print("\nMissing Values:")
+print(df.isnull().sum())
+
+sns.heatmap(df.isnull(), cbar=False, yticklabels=False)
+plt.title("Missing Values")
+plt.show()
+
+num_cols = df.select_dtypes(include="number").columns
+cat_cols = df.select_dtypes(exclude="number").columns
+
+for col in num_cols:
+    df[col] = df[col].fillna(df[col].median())
+
+for col in cat_cols:
+    df[col] = df[col].fillna(df[col].mode()[0])
+
+print("\nMissing Values After Handling:")
+print(df.isnull().sum())
+
+for col in num_cols:
+    sns.histplot(df[col], kde=True)
+    plt.title("Distribution of " + col)
+    plt.show()
+
+for col in cat_cols:
+    sns.countplot(data=df, x=col)
+    plt.title("Count of " + col)
+    plt.xticks(rotation=45)
+    plt.show()
+
+df = pd.get_dummies(df, columns=cat_cols, drop_first=True, dtype=int)
+
+scaler = StandardScaler()
+df[num_cols] = scaler.fit_transform(df[num_cols])
+
+print("\nPreprocessed Dataset:")
+print(df.head())
+
+plt.figure(figsize=(10, 6))
+sns.heatmap(df.corr(), annot=True, cmap="coolwarm")
+plt.title("Correlation Heatmap")
+plt.show()
+
+df.to_csv("Preprocessed_Data.csv", index=False)

daup-0.1.0/daup/_scripts/db.py

@@ -0,0 +1,73 @@
+import sqlite3
+
+conn = sqlite3.connect("employee.db")
+cursor = conn.cursor()
+
+cursor.execute("""
+CREATE TABLE IF NOT EXISTS Employee (
+    Emp_ID INTEGER PRIMARY KEY AUTOINCREMENT,
+    Name VARCHAR(100) NOT NULL,
+    Department VARCHAR(100) NOT NULL,
+    Salary REAL NOT NULL,
+    Designation VARCHAR(100) NOT NULL
+)
+""")
+conn.commit()
+
+cursor.execute("""
+INSERT INTO Employee (Name, Department, Salary, Designation)
+VALUES (?, ?, ?, ?)
+""", ("Anu", "HR", 45000, "Assistant Manager"))
+conn.commit()
+
+employees = [
+    ("Rahul", "IT", 60000, "Software Engineer"),
+    ("Meera", "Finance", 55000, "Accountant"),
+    ("Arun", "Production", 48000, "Supervisor")
+]
+
+cursor.executemany("""
+INSERT INTO Employee (Name, Department, Salary, Designation)
+VALUES (?, ?, ?, ?)
+""", employees)
+conn.commit()
+
+cursor.execute("SELECT * FROM Employee")
+print("All Employee Records:")
+for row in cursor.fetchall():
+    print(row)
+
+emp_id = 1
+cursor.execute("SELECT * FROM Employee WHERE Emp_ID = ?", (emp_id,))
+print("\nEmployee Search Result:")
+print(cursor.fetchone())
+
+cursor.execute("""
+UPDATE Employee
+SET Salary = ?
+WHERE Emp_ID = ?
+""", (65000, emp_id))
+conn.commit()
+
+cursor.execute("""
+UPDATE Employee
+SET Designation = ?
+WHERE Emp_ID = ?
+""", ("Senior Manager", emp_id))
+conn.commit()
+
+cursor.execute("""
+DELETE FROM Employee
+WHERE Emp_ID = ?
+""", (3,))
+conn.commit()
+
+cursor.execute("""
+SELECT * FROM Employee
+WHERE Salary > ?
+""", (50000,))
+print("\nEmployees earning more than ₹50,000:")
+for row in cursor.fetchall():
+    print(row)
+
+conn.close()

daup-0.1.0/daup/_scripts/dirty.py

@@ -0,0 +1,79 @@
+import pandas as pd
+import numpy as np
+
+df = pd.read_csv("dirtydata.csv")
+
+print("Original Dataset:")
+print(df)
+
+print("\nMissing Values:")
+print(df.isnull().sum())
+
+df_drop = df.dropna()
+print("\nRows after dropna():")
+print(df_drop)
+
+df_fill = df.copy()
+
+num_cols = df_fill.select_dtypes(include="number").columns
+cat_cols = df_fill.select_dtypes(include="object").columns
+
+for col in num_cols:
+    df_fill[col] = df_fill[col].fillna(df_fill[col].mean())
+
+for col in cat_cols:
+    df_fill[col] = df_fill[col].fillna(df_fill[col].mode()[0])
+
+print("\nMissing Values Filled:")
+print(df_fill)
+
+df_mean = df.copy()
+df_median = df.copy()
+df_mode = df.copy()
+
+for col in num_cols:
+    df_mean[col] = df_mean[col].fillna(df_mean[col].mean())
+    df_median[col] = df_median[col].fillna(df_median[col].median())
+    df_mode[col] = df_mode[col].fillna(df_mode[col].mode()[0])
+
+for col in cat_cols:
+    df_mean[col] = df_mean[col].fillna(df_mean[col].mode()[0])
+    df_median[col] = df_median[col].fillna(df_median[col].mode()[0])
+    df_mode[col] = df_mode[col].fillna(df_mode[col].mode()[0])
+
+print("\nFilled using Mean:")
+print(df_mean)
+
+print("\nFilled using Median:")
+print(df_median)
+
+print("\nFilled using Mode:")
+print(df_mode)
+
+print("\nData Types:")
+print(df.dtypes)
+
+for col in num_cols:
+    df[col] = pd.to_numeric(df[col], errors="coerce")
+
+for col in cat_cols:
+    df[col] = df[col].astype(str).str.strip()
+
+print("\nCorrected Data Types:")
+print(df.dtypes)
+
+print("\nRemove Invalid Data:")
+for col in df.select_dtypes(include="number").columns:
+    df = df[df[col] >= 0]
+
+print(df)
+
+print("\nDuplicate Rows:")
+print(df[df.duplicated()])
+
+df = df.drop_duplicates()
+
+print("\nDataset after Removing Duplicates:")
+print(df)
+
+df.to_csv("cleaned_dirtydata.csv", index=False)

daup-0.1.0/daup/_scripts/iris.py

@@ -0,0 +1,99 @@
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+from sklearn.datasets import load_iris
+from sklearn.preprocessing import StandardScaler
+from sklearn.cluster import KMeans
+from sklearn.decomposition import PCA
+
+iris=load_iris()
+
+X=pd.DataFrame(
+    iris.data,
+    columns=iris.feature_names
+)
+
+print(X.head())
+
+X.hist(figsize=(10,7),bins=20,edgecolor="black")
+plt.suptitle("Distributions ->")
+plt.tight_layout()
+plt.show()
+
+scalar=StandardScaler()
+X_sc=scalar.fit_transform(X)
+print(X_sc.shape)
+
+print("Feature mean : ",X_sc.mean(axis=0).round(2))
+
+print("Standard deviation : ",X_sc.std(axis=0).round(2))
+
+models={}
+cluster_lab={}
+
+for k in [2,3,4]:
+    
+    kmeans=KMeans(
+        n_clusters=k,
+        random_state=42,
+        n_init=10
+    )
+
+    labels=kmeans.fit_predict(X_sc)
+
+    models[k]=kmeans
+    cluster_lab[k]=labels
+
+    print(f"k={k}")
+    print("Cluster sizes : ",np.bincount(labels))
+    print("Inertia : ",round(kmeans.inertia_,2))
+
+inertias=[]
+for k in range(1,11):
+    kmeans=KMeans(
+        n_clusters=k,
+        random_state=42,
+        n_init=10
+    )
+
+    kmeans.fit(X_sc)
+
+    inertias.append(round(kmeans.inertia_,2))
+
+print(inertias)
+
+plt.figure(figsize=(8,5))
+plt.plot(range(1,11),inertias,marker="x")
+
+plt.xlabel("No. of clusters(k)--->")
+plt.ylabel("Inertias--->")
+plt.title("Elbow  method for optimal k")
+plt.xticks(list(range(1,11)))
+plt.grid(True)
+plt.show()
+
+pca=PCA(n_components=2)
+
+X_pca=pca.fit_transform(X_sc)
+print("Variance explained : ",pca.explained_variance_ratio_.round(3))
+
+fig,axes=plt.subplots(1,3,figsize=(18,5))
+
+for ax, k in zip(axes,[2,3,4]):
+    ax.scatter(
+        X_pca[:, 0],
+        X_pca[:, 1],
+        c=cluster_lab[k],
+        cmap="viridis",
+        s=50
+    )
+
+    ax.set_title(f"K-Means Clusters (k = {k})")
+    ax.set_xlabel("Principal Component 1")
+    ax.set_ylabel("Principal Component 2")
+
+plt.tight_layout()
+plt.show()
+

daup-0.1.0/daup/_scripts/pand.py

@@ -0,0 +1,172 @@
+import pandas as pd
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+# Q33: Student Series, DataFrame, Pass/Fail
+name = pd.Series(["Anu", "Rahul", "Meera", "Arun", "Sneha"])
+age = pd.Series([20, 21, 19, 22, 20])
+course = pd.Series(["B.Tech", "B.Sc", "B.Com", "B.Tech", "BCA"])
+marks = pd.Series([85, 35, 72, 40, 28])
+
+df = pd.DataFrame({"Name": name, "Age": age, "Course": course, "Marks": marks})
+df["Result"] = ["Pass" if m >= 40 else "Fail" for m in df["Marks"]]
+print(df[df["Result"] == "Pass"])
+
+
+# Q34: Department average salary and highest-paid employee
+df = pd.DataFrame({
+    "EmployeeID": [101, 102, 103, 104, 105],
+    "Name": ["Anu", "Rahul", "Meera", "Arun", "Sneha"],
+    "Department": ["HR", "IT", "HR", "IT", "Sales"],
+    "Salary": [40000, 60000, 45000, 75000, 50000]
+})
+
+print(df.groupby("Department")["Salary"].mean())
+print(df[df["Salary"] == df["Salary"].max()])
+
+
+# Q35: Monthly sales and grouped bar chart
+df = pd.DataFrame({
+    "Month": ["Jan", "Feb", "Mar", "Apr", "May", "Jun"],
+    "Product A": [150, 200, 180, 220, 250, 210],
+    "Product B": [180, 160, 210, 240, 200, 230],
+    "Product C": [120, 140, 160, 180, 210, 190]
+})
+
+df["Total"] = df[["Product A", "Product B", "Product C"]].sum(axis=1)
+print(df.loc[df["Total"].idxmax(), "Month"])
+
+df.plot(x="Month", y=["Product A", "Product B", "Product C"], kind="bar")
+plt.show()
+
+
+# Q36: Weather averages and temperature line plot
+df = pd.DataFrame({
+    "Day": ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"],
+    "Temperature": [28, 30, 29, 31, 27, 26, 28],
+    "Humidity": [70, 65, 75, 60, 80, 85, 72],
+    "Rainfall": [0, 2, 5, 0, 10, 8, 1]
+})
+
+print(df["Temperature"].mean())
+print(df["Rainfall"].sum())
+
+plt.plot(df["Day"], df["Temperature"], marker="o")
+plt.xlabel("Day")
+plt.ylabel("Temperature (°C)")
+plt.show()
+
+
+# Q37: Convert continuous age values into categories
+df = pd.DataFrame({
+    "Name": ["Alberto Franco", "Gino Mcneill", "Ryan Parkes",
+             "Eesha Hinton", "Syed Wharton"],
+    "Age": [18, 22, 40, 50, 80]
+})
+
+df["Age_Group"] = pd.cut(
+    df["Age"], bins=[0, 18, 40, 100],
+    labels=["Young", "Adult", "Senior"], include_lowest=True
+)
+print(df)
+
+
+# Q38: Concatenate DataFrames along rows
+student_data1 = pd.DataFrame({
+    "student_id": ["s1", "s2", "s3", "s4", "s5"],
+    "name": ["Danniella Fenton", "Ryder Storey", "Bryce Jensen",
+             "Ed Bernal", "Kwame Morin"],
+    "marks": [200, 210, 190, 222, 199]
+})
+
+student_data2 = pd.DataFrame({
+    "student_id": ["s4", "s5", "s6", "s7", "s8"],
+    "name": ["Scarlette Fisher", "Carla Williamson", "Dante Morse",
+             "Kaiser William", "Madeeha Preston"],
+    "marks": [201, 200, 198, 219, 201]
+})
+
+print(pd.concat([student_data1, student_data2], ignore_index=True))
+
+
+# Q39: Concatenate DataFrames along columns
+print(pd.concat([student_data1, student_data2], axis=1))
+
+
+# Q40: Concatenate student data and merge with exam data
+students = pd.concat([student_data1, student_data2], ignore_index=True)
+
+exam_data = pd.DataFrame({
+    "student_id": ["s1", "s2", "s3", "s4", "s5", "s7", "s8",
+                   "s9", "s10", "s11", "s12", "s13"],
+    "exam_id": [23, 45, 12, 67, 21, 55, 33, 14, 56, 83, 88, 12]
+})
+
+print(pd.merge(students, exam_data, on="student_id", how="inner"))
+
+
+# Q41: Inner join matching student IDs
+print(pd.merge(student_data1, student_data2, on="student_id", how="inner"))
+
+
+# Q42: Group by school and calculate age statistics
+df = pd.DataFrame({
+    "school": ["S1", "S2", "S3", "S4", "S5", "S6"],
+    "class": ["s001", "s002", "s003", "s001", "s002", "s004"],
+    "name": ["Alberto Franco", "Gino Mcneill", "Ryan Parkes",
+             "Eesha Hinton", "Gino Mcneill", "David Parkes"],
+    "date_Of_Birth": ["15/05/2002", "17/05/2002", "16/02/1999",
+                      "25/09/1998", "11/05/2002", "15/09/1997"],
+    "age": [12, 12, 13, 13, 14, 12],
+    "height": [173, 192, 186, 167, 151, 159],
+    "weight": [35, 32, 33, 30, 31, 32],
+    "address": ["street1", "street2", "street3", "street1", "street2", "street4"]
+})
+
+groups = df.groupby("school")
+print(type(groups))
+print(groups["age"].agg(["mean", "min", "max"]))
+
+
+# Q43: Count occurrences of each unique row
+df = pd.DataFrame({
+    "Id": [1, 2, 1, 1, 2, 1, 2],
+    "type": [10, 15, 11, 20, 21, 12, 14],
+    "book": ["Math", "English", "Physics", "Math",
+             "English", "Physics", "English"]
+})
+
+print(df.value_counts())
+
+
+# Q44: Alphabet stock data visualization
+df = pd.read_csv("alphabet_stock_data.csv")
+df["Date"] = pd.to_datetime(df["Date"])
+
+start_date = "2020-01-01"
+end_date = "2020-12-31"
+data = df[(df["Date"] >= start_date) & (df["Date"] <= end_date)]
+
+# Line plot of historical stock prices
+data.plot(x="Date", y=["Open", "Close", "High", "Low"])
+plt.title("Alphabet Stock Prices")
+plt.show()
+
+# Bar plot of trading volume
+data.plot(x="Date", y="Volume", kind="bar")
+plt.title("Trading Volume")
+plt.show()
+
+# Stacked histogram of stock prices
+data[["Open", "Close", "High", "Low"]].plot(
+    kind="hist", bins=30, stacked=True
+)
+plt.title("Stock Price Distribution")
+plt.show()
+
+# Scatter plot of volume vs closing price
+plt.scatter(data["Volume"], data["Close"])
+plt.xlabel("Trading Volume")
+plt.ylabel("Closing Price")
+plt.title("Volume vs Stock Price")
+plt.show()

daup-0.1.0/daup/_scripts/wine.py

@@ -0,0 +1,155 @@
+
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import StandardScaler
+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
+from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay
+
+red_url = "https://archive.ics.uci.edu/ml/machine-learning-databases/wine-quality/winequality-red.csv"
+white_url = "https://archive.ics.uci.edu/ml/machine-learning-databases/wine-quality/winequality-white.csv"
+
+red = pd.read_csv(red_url, sep=";")
+white = pd.read_csv(white_url, sep=";")
+
+print("Red wine shape:", red.shape)
+print("White wine shape:", white.shape)
+print("Red wine columns:", red.columns.tolist())
+print("White wine columns:", white.columns.tolist())
+print("\nRed wine:\n", red.head())
+print("\nWhite wine:\n", white.head())
+
+print("\nSame columns:", red.columns.equals(white.columns))
+
+red["wine_type"] = "red"
+white["wine_type"] = "White"
+
+wine = pd.concat([red, white], ignore_index=True)
+
+print("\nIntegrated shape:", wine.shape)
+print("Unique wine types:", wine["wine_type"].unique())
+print("Wine type counts:\n", wine["wine_type"].value_counts())
+
+wine.to_csv("integrated_wine_quality.csv", index=False)
+
+print("\nMissing values:\n", wine.isnull().sum())
+print("Duplicate rows:", wine.duplicated().sum())
+
+wine = wine.drop_duplicates()
+
+print("Shape after removing duplicates:", wine.shape)
+
+y = wine["quality"]
+X = wine.drop("quality", axis=1)
+
+X = pd.get_dummies(X, columns=["wine_type"], drop_first=True, dtype=int)
+
+X_train, X_test, y_train, y_test = train_test_split(
+    X, y, test_size=0.2, random_state=42
+)
+
+scaler = StandardScaler()
+
+X_train_scaled = scaler.fit_transform(X_train)
+X_test_scaled = scaler.transform(X_test)
+
+plt.figure(figsize=(8, 5))
+sns.countplot(data=wine, x="quality")
+plt.title("Distribution of Wine Quality Scores")
+plt.xlabel("Quality")
+plt.ylabel("Number of wines")
+plt.show()
+
+plt.figure(figsize=(8, 5))
+sns.boxplot(data=wine, x="wine_type", y="quality")
+plt.title("Wine Quality by Wine Type")
+plt.xlabel("Wine Type")
+plt.ylabel("Quality Score")
+plt.show()
+
+average_quality = wine.groupby("wine_type")["quality"].mean()
+print("\nAverage quality:\n", average_quality)
+
+correlation = wine.drop(columns="wine_type").corr()
+
+plt.figure(figsize=(12, 8))
+sns.heatmap(correlation, annot=True, cmap="coolwarm", fmt=".2f")
+plt.title("Correlation Heatmap")
+plt.show()
+
+quality_corr = correlation["quality"].drop("quality")
+
+top_3 = quality_corr.reindex(
+    quality_corr.abs().sort_values(ascending=False).index
+).head(3)
+
+print("\nTop 3 features correlated with quality:\n", top_3)
+
+plt.figure(figsize=(8, 5))
+sns.scatterplot(data=wine, x="alcohol", y="quality", hue="wine_type")
+plt.title("Alcohol vs Wine Quality")
+plt.xlabel("Alcohol")
+plt.ylabel("Quality")
+plt.show()
+
+models = {
+    "Linear Regression": LinearRegression(),
+    "Decision Tree": DecisionTreeRegressor(random_state=42),
+    "Random Forest": RandomForestRegressor(
+        n_estimators=100, random_state=42
+    )
+}
+
+results = []
+
+for name, model in models.items():
+    model.fit(X_train_scaled, y_train)
+    y_pred = model.predict(X_test_scaled)
+
+    r2 = r2_score(y_test, y_pred)
+    mae = mean_absolute_error(y_test, y_pred)
+    mse = mean_squared_error(y_test, y_pred)
+    rmse = np.sqrt(mse)
+
+    results.append({
+        "Model": name,
+        "R2": r2,
+        "MAE": mae,
+        "MSE": mse,
+        "RMSE": rmse
+    })
+
+results_df = pd.DataFrame(results)
+
+print("\nModel Evaluation Results:")
+print(results_df.round(4))
+
+
+for name, model in models.items():
+    y_pred = model.predict(X_test_scaled)
+
+    y_pred_rounded = np.clip(np.rint(y_pred), 0, 10).astype(int)
+    y_test_int = y_test.astype(int)
+
+    labels = sorted(set(y_test_int) | set(y_pred_rounded))
+
+    cm = confusion_matrix(
+        y_test_int,
+        y_pred_rounded,
+        labels=labels
+    )
+
+    disp = ConfusionMatrixDisplay(
+        confusion_matrix=cm,
+        display_labels=labels
+    )
+
+    disp.plot(cmap="Blues", values_format="d")
+    plt.title(f"Confusion Matrix - {name}")
+    plt.show()

daup-0.1.0/daup.egg-info/PKG-INFO

@@ -0,0 +1,48 @@
+Metadata-Version: 2.4
+Name: daup
+Version: 0.1.0
+Summary: Download bundled Python practical scripts with simple functions
+Author: Daup maintainer
+License: MIT
+Keywords: python,scripts,education,download
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# daup
+
+A small Python package that copies bundled example scripts into your current directory.
+
+## Install
+
+```bash
+pip install daup
+```
+
+## Usage
+
+```python
+import daup
+
+daup.api()       # creates api.py in the current directory
+daup.bcan()      # creates bcan.py
+daup.cgi()       # creates cgi.py
+daup.data()      # creates data.py
+daup.db()        # creates db.py
+daup.dirty()     # creates dirty.py
+daup.iris()      # creates iris.py
+daup.pand()      # creates pand.py
+daup.wine()      # creates wine.py
+```
+
+Pass an optional destination directory:
+
+```python
+daup.api("downloads")
+```
+
+Each function returns the absolute path to the copied file. Existing files with the same name are overwritten.

daup-0.1.0/daup.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+LICENSE
+README.md
+pyproject.toml
+daup/__init__.py
+daup.egg-info/PKG-INFO
+daup.egg-info/SOURCES.txt
+daup.egg-info/dependency_links.txt
+daup.egg-info/top_level.txt
+daup/_scripts/api.py
+daup/_scripts/bcan.py
+daup/_scripts/cgi.py
+daup/_scripts/data.py
+daup/_scripts/db.py
+daup/_scripts/dirty.py
+daup/_scripts/iris.py
+daup/_scripts/pand.py
+daup/_scripts/wine.py

daup-0.1.0/daup.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

daup-0.1.0/daup.egg-info/top_level.txt

@@ -0,0 +1 @@
+daup

daup-0.1.0/pyproject.toml

@@ -0,0 +1,21 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "daup"
+version = "0.1.0"
+description = "Download bundled Python practical scripts with simple functions"
+readme = "README.md"
+requires-python = ">=3.9"
+license = {text = "MIT"}
+authors = [{name = "Daup maintainer"}]
+keywords = ["python", "scripts", "education", "download"]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Operating System :: OS Independent",
+]
+
+[tool.setuptools.package-data]
+daup = ["_scripts/*.py"]

daup-0.1.0/setup.cfg

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