aunties 0.1.0__tar.gz

aunties-0.1.0/PKG-INFO

@@ -0,0 +1,120 @@
+Metadata-Version: 2.4
+Name: aunties
+Version: 0.1.0
+Summary: A simple library for displaying AI and Cybersecurity practical source code
+Author: Aunties Contributors
+License-Expression: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# Aunties — Python Practical Code Library
+
+Aunties is a simple, free Python library that provides source code for practical programs from two subjects:
+
+- **Artificial Intelligence (AI)**
+- **Cyber and Information Security (CIS)**
+
+The library allows users to display the complete source code of a practical directly in the terminal using a simple Python function.
+
+## Features
+
+- Stores practical programs organized by subject.
+- Displays source code using a simple keyword.
+- Preserves indentation, blank lines, and code formatting.
+- Supports adding new practicals without modifying the main function.
+- Open-source and designed for students and learners.
+
+## Installation
+
+Install the library using pip:
+
+```bash
+pip install aunties
+```
+
+*Note: This command will work once the package has been published on PyPI. To install the project before publication, see the Development section.*
+
+## Usage
+
+Import the `show` function:
+
+```python
+from aunties import show
+```
+
+Display a practical by passing its keyword:
+
+```python
+show("caesar")
+```
+
+Display another practical:
+
+```python
+show("rsa")
+```
+
+The library prints the complete source code of the selected practical in the terminal.
+
+## Available Practicals
+
+Practical keywords are based on their filenames without the `.py` extension.
+
+| Subject | Filename | Keyword |
+|---|---|---|
+| Cyber and Information Security | `caesar.py` | `caesar` |
+| Cyber and Information Security | `rsa.py` | `rsa` |
+| Artificial Intelligence | `bfs.py` | `bfs` |
+| Artificial Intelligence | `minimax.py` | `minimax` |
+
+The table shows examples. Actual availability depends on the practical files included in the installed version.
+
+## Project Structure
+
+```text
+aunties/
+├── pyproject.toml
+├── README.md
+└── src/
+    └── aunties/
+        ├── __init__.py
+        ├── show.py
+        └── codes/
+            ├── ai/
+            └── cis/
+```
+
+## Adding a New Practical
+
+1. Open the appropriate subject folder inside `codes/`.
+2. Create a Python file, such as `vigenere.py`.
+3. Add the practical's source code to that file.
+4. Use its filename as the keyword:
+
+```python
+show("vigenere")
+```
+
+No changes to `show.py` are required when adding a uniquely named practical.
+
+## Development
+
+To install the project locally in editable mode, clone or download the repository, navigate to its root directory, and run:
+
+```bash
+python -m pip install -e .
+```
+
+You can then import and test the library in your Python scripts.
+
+## Important Note
+
+Aunties displays source code as text. It does not execute the displayed practical or perform encryption, decryption, or AI operations automatically.
+
+## Contributing
+
+Contributions are welcome. You can help by adding practical programs, improving documentation, fixing bugs, or suggesting improvements.
+
+## License
+
+This project is intended to be open-source. The

aunties-0.1.0/README.md

@@ -0,0 +1,111 @@
+# Aunties — Python Practical Code Library
+
+Aunties is a simple, free Python library that provides source code for practical programs from two subjects:
+
+- **Artificial Intelligence (AI)**
+- **Cyber and Information Security (CIS)**
+
+The library allows users to display the complete source code of a practical directly in the terminal using a simple Python function.
+
+## Features
+
+- Stores practical programs organized by subject.
+- Displays source code using a simple keyword.
+- Preserves indentation, blank lines, and code formatting.
+- Supports adding new practicals without modifying the main function.
+- Open-source and designed for students and learners.
+
+## Installation
+
+Install the library using pip:
+
+```bash
+pip install aunties
+```
+
+*Note: This command will work once the package has been published on PyPI. To install the project before publication, see the Development section.*
+
+## Usage
+
+Import the `show` function:
+
+```python
+from aunties import show
+```
+
+Display a practical by passing its keyword:
+
+```python
+show("caesar")
+```
+
+Display another practical:
+
+```python
+show("rsa")
+```
+
+The library prints the complete source code of the selected practical in the terminal.
+
+## Available Practicals
+
+Practical keywords are based on their filenames without the `.py` extension.
+
+| Subject | Filename | Keyword |
+|---|---|---|
+| Cyber and Information Security | `caesar.py` | `caesar` |
+| Cyber and Information Security | `rsa.py` | `rsa` |
+| Artificial Intelligence | `bfs.py` | `bfs` |
+| Artificial Intelligence | `minimax.py` | `minimax` |
+
+The table shows examples. Actual availability depends on the practical files included in the installed version.
+
+## Project Structure
+
+```text
+aunties/
+├── pyproject.toml
+├── README.md
+└── src/
+    └── aunties/
+        ├── __init__.py
+        ├── show.py
+        └── codes/
+            ├── ai/
+            └── cis/
+```
+
+## Adding a New Practical
+
+1. Open the appropriate subject folder inside `codes/`.
+2. Create a Python file, such as `vigenere.py`.
+3. Add the practical's source code to that file.
+4. Use its filename as the keyword:
+
+```python
+show("vigenere")
+```
+
+No changes to `show.py` are required when adding a uniquely named practical.
+
+## Development
+
+To install the project locally in editable mode, clone or download the repository, navigate to its root directory, and run:
+
+```bash
+python -m pip install -e .
+```
+
+You can then import and test the library in your Python scripts.
+
+## Important Note
+
+Aunties displays source code as text. It does not execute the displayed practical or perform encryption, decryption, or AI operations automatically.
+
+## Contributing
+
+Contributions are welcome. You can help by adding practical programs, improving documentation, fixing bugs, or suggesting improvements.
+
+## License
+
+This project is intended to be open-source. The

aunties-0.1.0/pyproject.toml

@@ -0,0 +1,20 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "aunties"
+version = "0.1.0"
+description = "A simple library for displaying AI and Cybersecurity practical source code"
+readme = "README.md"
+requires-python = ">=3.9"
+license = "MIT"
+authors = [
+    { name = "Aunties Contributors" }
+]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+aunties = ["codes/**/*.py"]

aunties-0.1.0/setup.cfg

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

aunties-0.1.0/src/aunties/__init__.py

@@ -0,0 +1,3 @@
+from .show import show
+
+__all__ = ["show"]

aunties-0.1.0/src/aunties/codes/ai/Adaboost.py

@@ -0,0 +1,33 @@
+from sklearn.datasets import load_breast_cancer
+from sklearn.model_selection import train_test_split
+from sklearn.tree import DecisionTreeClassifier
+from sklearn.ensemble import AdaBoostClassifier
+from sklearn.metrics import accuracy_score
+import matplotlib.pyplot as plt
+
+data = load_breast_cancer()
+X, y = data.data, data.target
+
+X_train, X_test, y_train, y_test = train_test_split(
+    X, y, test_size=0.3, random_state=4
+)
+
+weak = DecisionTreeClassifier(max_depth=1, random_state=4)
+weak.fit(X_train, y_train)
+weak_acc = accuracy_score(y_test, weak.predict(X_test))
+
+ada = AdaBoostClassifier(
+    estimator=DecisionTreeClassifier(max_depth=1),
+    n_estimators=50, random_state=4
+)
+ada.fit(X_train, y_train)
+ada_acc = accuracy_score(y_test, ada.predict(X_test))
+
+print("Weak Classifier Accuracy:", weak_acc)
+print("AdaBoost Accuracy:", ada_acc)
+
+plt.bar(["Weak Classifier", "AdaBoost"], [weak_acc, ada_acc])
+plt.xlabel("Model")
+plt.ylabel("Accuracy")
+plt.title("Weak Classifier vs AdaBoost")
+plt.show()

aunties-0.1.0/src/aunties/codes/ai/Astar.py

@@ -0,0 +1,42 @@
+import heapq
+
+def a_star(graph, start, goal, heuristic):
+    queue = [(heuristic[start], start)]
+    cost = {start: 0}
+    parent = {start: None}
+
+    while queue:
+        _, node = heapq.heappop(queue)
+
+        if node == goal:
+            path = []
+            while node is not None:
+                path.append(node)
+                node = parent[node]
+            return path[::-1], cost[goal]
+
+        for neighbor, weight in graph[node]:
+            new_cost = cost[parent[node]] + weight if False else cost.get(node, 0) + weight
+
+            if neighbor not in cost or new_cost < cost[neighbor]:
+                cost[neighbor] = new_cost
+                parent[neighbor] = node
+                heapq.heappush(queue, (new_cost + heuristic[neighbor], neighbor))
+
+    return None, float("inf")
+
+
+graph = {
+    'A': [('B', 1), ('C', 4)],
+    'B': [('A', 1), ('C', 2), ('D', 5)],
+    'C': [('A', 4), ('B', 2), ('D', 1)],
+    'D': [('B', 5), ('C', 1), ('E', 3)],
+    'E': [('D', 3)]
+}
+
+heuristic = {'A': 7, 'B': 6, 'C': 2, 'D': 1, 'E': 0}
+
+path, cost = a_star(graph, 'A', 'E', heuristic)
+
+print("A* Path:", path)
+print("Path Cost:", cost)

aunties-0.1.0/src/aunties/codes/ai/BFS.py

@@ -0,0 +1,93 @@
+
+import time
+from collections import deque
+
+graph = {
+    'A': ['B', 'C'],
+    'B': ['A', 'D', 'E'],
+    'C': ['A', 'F'],
+    'D': ['B'],
+    'E': ['B', 'G', 'H'],
+    'F': ['C', 'I'],
+    'G': ['E'],
+    'H': ['E'],
+    'I': ['F']
+}
+
+START, GOAL = 'A', 'I'
+
+#BFS
+
+def bfs(graph, start, goal):
+    queue = deque([[start]])
+    visited = set()
+    count = 0
+
+    while queue:
+        path = queue.popleft()
+        node = path[-1]
+
+        if node == goal:
+            return path, count
+
+        if node not in visited:
+            visited.add(node)
+            count += 1
+
+            for neighbor in graph.get(node, []):
+                queue.append(path + [neighbor])
+
+    return None, count
+
+
+def dls(graph, node, goal, depth, path, visited, count):
+    count[0] += 1
+
+    if node == goal:
+        return path
+
+    if depth == 0:
+        return None
+
+    visited.add(node)
+
+    for neighbor in graph.get(node, []):
+        if neighbor not in visited:
+            result = dls(graph, neighbor, goal, depth - 1,
+                         path + [neighbor], visited, count)
+            if result:
+                return result
+
+    visited.remove(node)
+    return None
+
+#IDDFS
+
+def iddfs(graph, start, goal, max_depth=10):
+    count = [0]
+
+    for depth in range(max_depth + 1):
+        result = dls(graph, start, goal, depth,
+                     [start], set(), count)
+        if result:
+            return result, count[0]
+
+    return None, count[0]
+
+#Compare Both
+
+def compare():
+    for name, search in [('BFS', bfs), ('IDDFS', iddfs)]:
+        start = time.time()
+        path, nodes = search(graph, START, GOAL)
+        elapsed = time.time() - start
+
+        print(f"\n{name} Result")
+        print("Path:", path)
+        print("Path Length:", len(path) if path else 0)
+        print("Nodes Expanded:", nodes)
+        print(f"Time Taken: {elapsed:.6f} seconds")
+
+
+if __name__ == "__main__":
+    compare()

aunties-0.1.0/src/aunties/codes/ai/Back.py

@@ -0,0 +1,24 @@
+
+from sklearn.datasets import load_iris
+from sklearn.model_selection import train_test_split
+from sklearn.neural_network import MLPClassifier
+from sklearn.metrics import accuracy_score
+
+iris = load_iris()
+X, y = iris.data, iris.target
+
+X_train, X_test, y_train, y_test = train_test_split(
+    X, y, test_size=0.2, random_state=42
+)
+
+model = MLPClassifier(hidden_layer_sizes=(10,), max_iter=1000,
+                      random_state=42)
+model.fit(X_train, y_train)
+
+pred = model.predict(X_test)
+accuracy = accuracy_score(y_test, pred)
+
+print("Actual values:   ", y_test)
+print("Predicted values:", pred)
+print("Accuracy:", accuracy)
+print("Accuracy (%):", accuracy * 100)

aunties-0.1.0/src/aunties/codes/ai/Bayes.py

@@ -0,0 +1,37 @@
+
+import matplotlib.pyplot as plt
+from sklearn.datasets import load_iris
+from sklearn.model_selection import train_test_split
+from sklearn.naive_bayes import GaussianNB
+from sklearn.metrics import accuracy_score, confusion_matrix, ConfusionMatrixDisplay
+
+iris = load_iris()
+X, y = iris.data, iris.target
+
+X_train, X_test, y_train, y_test = train_test_split(
+    X, y, test_size=0.2, random_state=42
+)
+
+model = GaussianNB()
+model.fit(X_train, y_train)
+pred = model.predict(X_test)
+
+accuracy = accuracy_score(y_test, pred)
+print("Accuracy:", accuracy * 100, "%")
+print("Class Probabilities:\n", model.predict_proba(X_test))
+print("Actual Values:", y_test[:5])
+print("Predicted Values:", pred[:5])
+
+cm = confusion_matrix(y_test, pred)
+ConfusionMatrixDisplay(
+    confusion_matrix=cm, display_labels=iris.target_names
+).plot(cmap="Blues")
+
+plt.title("Naive Bayes Confusion Matrix")
+plt.show()
+
+plt.bar(["Accuracy"], [accuracy * 100], color="green")
+plt.ylabel("Accuracy (%)")
+plt.title("Naive Bayes Model Accuracy")
+plt.ylim(0, 100)
+plt.show()

aunties-0.1.0/src/aunties/codes/ai/Dtree.py

@@ -0,0 +1,28 @@
+
+import matplotlib.pyplot as plt
+from sklearn.datasets import load_iris
+from sklearn.model_selection import train_test_split
+from sklearn.tree import DecisionTreeClassifier, plot_tree, export_text
+from sklearn.metrics import accuracy_score, confusion_matrix, classification_report
+
+iris = load_iris()
+X, y = iris.data, iris.target
+
+X_train, X_test, y_train, y_test = train_test_split(
+    X, y, test_size=0.25, random_state=42, stratify=y
+)
+
+model = DecisionTreeClassifier(random_state=42)
+model.fit(X_train, y_train)
+pred = model.predict(X_test)
+
+print("Accuracy:", accuracy_score(y_test, pred))
+print("Confusion Matrix:\n", confusion_matrix(y_test, pred))
+print("Classification Report:\n",
+      classification_report(y_test, pred, target_names=iris.target_names))
+print("Decision Tree:\n", export_text(model, feature_names=iris.feature_names))
+
+plt.figure(figsize=(12, 8))
+plot_tree(model, feature_names=iris.feature_names,
+          class_names=iris.target_names, filled=True, rounded=True)
+plt.show()

aunties-0.1.0/src/aunties/codes/ai/KNN.py

@@ -0,0 +1,34 @@
+from sklearn.datasets import load_iris
+from sklearn.neighbors import KNeighborsClassifier
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import accuracy_score
+import matplotlib.pyplot as plt
+
+iris = load_iris()
+X, y = iris.data[:, :2], iris.target
+
+X_train, X_test, y_train, y_test = train_test_split(
+    X, y, test_size=0.3, random_state=43
+)
+
+model = KNeighborsClassifier(n_neighbors=3)
+model.fit(X_train, y_train)
+pred = model.predict(X_test)
+
+print("Actual values:", y_test)
+print("Predicted values:", pred)
+print("Accuracy:", accuracy_score(y_test, pred) * 100, "%")
+
+new_data = [[5.0, 3.5]]
+result = model.predict(new_data)[0]
+
+print("New data:", new_data)
+print("Predicted class:", result)
+print("Flower name:", iris.target_names[result])
+
+plt.scatter(X[:, 0], X[:, 1], c=y)
+plt.scatter(5.0, 3.5, color="red", marker="*", s=150)
+plt.xlabel("Sepal Length")
+plt.ylabel("Sepal Width")
+plt.title("Iris Dataset - KNN")
+plt.show()

aunties-0.1.0/src/aunties/codes/ai/Mining.py

@@ -0,0 +1,19 @@
+import pandas as pd
+from mlxtend.frequent_patterns import apriori, association_rules
+
+data = pd.DataFrame([
+    [1, 1, 1, 0],
+    [1, 1, 0, 1],
+    [1, 0, 1, 0],
+    [1, 1, 1, 1],
+    [0, 1, 1, 1]
+], columns=["Bread", "Milk", "Butter", "Eggs"])
+
+items = apriori(data.astype(bool), min_support=0.4, use_colnames=True)
+rules = association_rules(items, metric="confidence", min_threshold=0.6)
+
+print("Frequent Itemsets:")
+print(items)
+
+print("\nAssociation Rules:")
+print(rules[["antecedents", "consequents", "support", "confidence", "lift"]])

aunties-0.1.0/src/aunties/codes/ai/Open.py

@@ -0,0 +1,33 @@
+import tensorflow as tf
+import matplotlib.pyplot as plt
+
+(X_train, y_train), (X_test, y_test) = tf.keras.datasets.mnist.load_data()
+
+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(10, activation="softmax")
+])
+
+model.compile(optimizer="adam",
+              loss="sparse_categorical_crossentropy",
+              metrics=["accuracy"])
+
+model.fit(X_train, y_train, epochs=3)
+
+loss, accuracy = model.evaluate(X_test, y_test)
+print("Test Accuracy:", accuracy * 100, "%")
+
+i = 0
+prediction = model.predict(X_test[i:i+1], verbose=0)
+
+print("Actual Digit:", y_test[i])
+print("Predicted Digit:", prediction.argmax())
+
+plt.imshow(X_test[i], cmap="gray")
+plt.title("Predicted Digit: " + str(prediction.argmax()))
+plt.axis("off")
+plt.show()

aunties-0.1.0/src/aunties/codes/ai/RBFS.py

@@ -0,0 +1,52 @@
+
+graph = {
+    'A': [('B', 1), ('C', 4)],
+    'B': [('A', 1), ('C', 2), ('D', 5)],
+    'C': [('A', 4), ('B', 2), ('D', 1)],
+    'D': [('B', 5), ('C', 1), ('E', 3)],
+    'E': [('D', 3)]
+}
+
+heuristic = {'A': 7, 'B': 6, 'C': 2, 'D': 1, 'E': 0}
+
+
+def rbfs(graph, node, goal, g, limit, heuristic, path):
+    if node == goal:
+        return path, g
+
+    successors = []
+
+    for neighbor, cost in graph[node]:
+        if neighbor not in path:
+            new_g = g + cost
+            f = max(new_g + heuristic[neighbor], heuristic[node])
+            successors.append([neighbor, new_g, f])
+
+    if not successors:
+        return None, float("inf")
+
+    while True:
+        successors.sort(key=lambda x: x[2])
+        best = successors[0]
+
+        if best[2] > limit:
+            return None, best[2]
+
+        alternative = successors[1][2] if len(successors) > 1 else float("inf")
+
+        result, new_f = rbfs(
+            graph, best[0], goal, best[1],
+            min(limit, alternative), heuristic,
+            path + [best[0]]
+        )
+
+        best[2] = new_f
+
+        if result is not None:
+            return result, new_f
+
+
+path, cost = rbfs(graph, 'A', 'E', 0, float("inf"), heuristic, ['A'])
+
+print("RBFS Path:", path)
+print("Path Cost:", cost)

aunties-0.1.0/src/aunties/codes/ai/SVM.py

@@ -0,0 +1,40 @@
+
+from sklearn.datasets import load_iris
+from sklearn.svm import SVC
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import accuracy_score, confusion_matrix, classification_report
+import matplotlib.pyplot as plt
+
+iris = load_iris()
+X, y = iris.data, iris.target
+
+mask = y != 2
+X, y = X[mask, :2], y[mask]
+
+X_train, X_test, y_train, y_test = train_test_split(
+    X, y, test_size=0.3, random_state=43
+)
+
+model = SVC(kernel='linear')
+model.fit(X_train, y_train)
+pred = model.predict(X_test)
+
+print("Actual values:", y_test)
+print("Predicted values:", pred)
+print("Accuracy:", accuracy_score(y_test, pred) * 100, "%")
+print("Confusion Matrix:\n", confusion_matrix(y_test, pred))
+print("Classification Report:\n", classification_report(y_test, pred))
+
+new_data = [[5.0, 3.5]]
+result = model.predict(new_data)[0]
+
+print("New data:", new_data)
+print("Predicted class:", result)
+print("Flower name:", iris.target_names[result])
+
+plt.scatter(X[:, 0], X[:, 1], c=y)
+plt.scatter(5.0, 3.5, color='red', marker='*', s=150)
+plt.xlabel("Sepal Length")
+plt.ylabel("Sepal Width")
+plt.title("Iris Dataset - SVM")
+plt.show()

aunties-0.1.0/src/aunties/codes/cis/TLS.py

@@ -0,0 +1,54 @@
+#command
+"openssl req -x509 -newkey rsa:2048 -keyout server.key -out server.crt -days 365 -nodes"
+
+
+#Client Side
+
+
+import socket
+import ssl
+
+context = ssl.create_default_context()
+context.check_hostname = False
+context.verify_mode = ssl.CERT_NONE
+
+with socket.create_connection(("localhost", 5000)) as s:
+    with context.wrap_socket(s, server_hostname="localhost") as conn:
+        print("TLS Version:", conn.version())
+
+        while True:
+            msg = input("You: ")
+            conn.sendall(msg.encode())
+            print("Server:", conn.recv(1024).decode())
+
+            if msg.upper() == "BYE":
+                break
+
+#Server Side
+
+
+import socket
+import ssl
+
+context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
+context.load_cert_chain("server.crt", "server.key")
+
+server = socket.socket()
+server.bind(("localhost", 5000))
+server.listen(1)
+
+print("TLS Server running...")
+
+while True:
+    client, address = server.accept()
+
+    with context.wrap_socket(client, server_side=True) as conn:
+        print("Secure connection:", address)
+
+        while True:
+            msg = conn.recv(1024).decode()
+            print("Client:", msg)
+            conn.sendall(b"Message Received")
+
+            if msg.upper() == "BYE":
+                break

aunties-0.1.0/src/aunties/codes/cis/ceasar.py

@@ -0,0 +1,19 @@
+def encrypt(text, shift):
+    result = ""
+
+    for ch in text:
+        if ch.isalpha():
+            start = ord('A') if ch.isupper() else ord('a')
+            result += chr((ord(ch) - start + shift) % 26 + start)
+        else:
+            result += ch
+
+    return result
+
+
+message = input("Enter Message: ")
+shift = int(input("Enter Shift Value: "))
+
+encrypted = encrypt(message, shift)
+print("Encrypted Message:", encrypted)
+print("Decrypted Message:", encrypt(encrypted, -shift))

aunties-0.1.0/src/aunties/codes/cis/fence.py

@@ -0,0 +1,21 @@
+def encrypt(text, rails):
+    fence = [''] * rails
+    row, step = 0, 1
+
+    for ch in text:
+        fence[row] += ch
+        if row == 0:
+            step = 1
+        elif row == rails - 1:
+            step = -1
+        row += step
+
+    return ''.join(fence)
+
+
+msg = input("Enter Message: ")
+rails = int(input("Enter Rails: "))
+
+cipher = encrypt(msg, rails)
+
+print("Encrypted Message:", cipher)

aunties-0.1.0/src/aunties/codes/cis/hellman.py

@@ -0,0 +1,33 @@
+#Sender
+
+p = int(input("Enter prime number p: "))
+g = int(input("Enter primitive root g: "))
+
+a = int(input("Enter Sender private key: "))
+
+A = pow(g, a, p)
+
+print("\nSender Public Key:", A)
+
+B = int(input("Enter Receiver Public Key: "))
+
+shared_key = pow(B, a, p)
+
+print("Sender Shared Key:", shared_key)
+
+#Reciever
+
+p = int(input("Enter prime number p: "))
+g = int(input("Enter primitive root g: "))
+
+b = int(input("Enter Receiver private key: "))
+
+B = pow(g, b, p)
+
+print("\nReceiver Public Key:", B)
+
+A = int(input("Enter Sender Public Key: "))
+
+shared_key = pow(A, b, p)
+
+print("Receiver Shared Key:", shared_key)

aunties-0.1.0/src/aunties/codes/cis/hmac.py

@@ -0,0 +1,34 @@
+#sender
+
+import hmac
+import hashlib
+
+message = input("Enter Message: ")
+key = input("Enter Secret Key: ")
+
+mac = hmac.new(key.encode(), message.encode(), hashlib.sha256).hexdigest()
+
+print("\n----- Sender -----")
+print("Message :", message)
+print("Key     :", key)
+print("Generated MAC :", mac)
+
+#reciever
+
+import hmac
+import hashlib
+
+
+received_message = input("Enter Received Message: ")
+key = input("Enter Secret Key: ")
+received_mac = input("Enter Received MAC: ")
+
+new_mac = hmac.new(key.encode(), received_message.encode(), hashlib.sha256).hexdigest()
+
+
+if hmac.compare_digest(new_mac, received_mac):
+    print("\nMessage is Authentic.")
+    print("MAC Verification Successful.")
+else:
+    print("\nMessage Authentication Failed!")
+    print("Message has been Tampered.")

aunties-0.1.0/src/aunties/codes/cis/ids.py

@@ -0,0 +1,46 @@
+#IDS
+
+
+from scapy.all import sniff, IP, TCP, get_if_list
+
+ports = {}
+THRESHOLD = 5
+
+def detect(packet):
+    if packet.haslayer(IP) and packet.haslayer(TCP):
+        ip = packet[IP].src
+        port = packet[TCP].dport
+
+        if packet[TCP].flags == "S":
+            ports.setdefault(ip, set()).add(port)
+            print(f"Connection attempt: {ip} -> Port {port}")
+
+            if len(ports[ip]) >= THRESHOLD:
+                print(f"[ALERT] Possible Port Scan from {ip}")
+                ports[ip].clear()
+
+print("Python Based IDS Running...")
+interfaces = get_if_list()
+print("Interfaces:", interfaces)
+
+sniff(iface=interfaces, filter="tcp", prn=detect, store=False)
+
+
+#TEST
+
+
+import socket
+
+target = "127.0.0.1"
+
+print("Starting Port Scan Test...")
+
+for port in range(5000, 5051):
+    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    s.settimeout(0.1)
+    result = s.connect_ex((target, port))
+
+    print(f"Port {port}:", "OPEN" if result == 0 else "CLOSED")
+    s.close()
+
+print("Port Testing Completed.")

aunties-0.1.0/src/aunties/codes/cis/pss.py

@@ -0,0 +1,58 @@
+#Sender
+
+from cryptography.hazmat.primitives.asymmetric import rsa, padding
+from cryptography.hazmat.primitives import hashes, serialization
+
+private_key = rsa.generate_private_key(public_exponent=65537, key_size=2048)
+public_key = private_key.public_key()
+
+with open("public_key.pem", "wb") as f:
+    f.write(public_key.public_bytes(
+        serialization.Encoding.PEM,
+        serialization.PublicFormat.SubjectPublicKeyInfo
+    ))
+
+message = b"Hello Receiver"
+
+signature = private_key.sign(
+    message,
+    padding.PSS(mgf=padding.MGF1(hashes.SHA256()),
+                salt_length=padding.PSS.MAX_LENGTH),
+    hashes.SHA256()
+)
+
+open("message.txt", "wb").write(message)
+open("signature.sig", "wb").write(signature)
+
+print("Message and Signature Sent")
+
+
+#Reciever
+
+
+from cryptography.hazmat.primitives.asymmetric import padding
+from cryptography.hazmat.primitives import hashes, serialization
+from cryptography.exceptions import InvalidSignature
+
+with open("public_key.pem", "rb") as f:
+    public_key = serialization.load_pem_public_key(f.read())
+
+with open("message.txt", "rb") as f:
+    message = f.read()
+
+with open("signature.sig", "rb") as f:
+    signature = f.read()
+
+try:
+    public_key.verify(
+        signature,
+        message,
+        padding.PSS(mgf=padding.MGF1(hashes.SHA256()),
+                    salt_length=padding.PSS.MAX_LENGTH),
+        hashes.SHA256()
+    )
+    print("Signature Verified")
+    print("Message is Authentic")
+except InvalidSignature:
+    print("Signature Verification Failed")
+    print("Message has been Tampered")

aunties-0.1.0/src/aunties/codes/cis/rsa.py

@@ -0,0 +1,37 @@
+#sender
+
+import math
+
+p = int(input("Enter p: "))
+q = int(input("Enter q: "))
+message = input("Enter message: ")
+
+n = p * q
+phi = (p - 1) * (q - 1)
+
+e = 2
+while e < phi:
+    if math.gcd(e, phi) == 1:
+        break
+    e += 1
+
+d = pow(e, -1, phi)
+
+ciphertext = [str(pow(ord(ch), e, n)) for ch in message]
+
+print("Public Key:", e, n)
+print("Private Key:", d, n)
+print("Cipher Text:", " ".join(ciphertext))
+
+#reciever
+
+d = int(input("Enter d: "))
+n = int(input("Enter n: "))
+ciphertext = input("Enter cipher text: ")
+
+message = ""
+
+for c in ciphertext.split():
+    message += chr(pow(int(c), d, n))
+
+print("Decrypted Message:", message)

aunties-0.1.0/src/aunties/show.py

@@ -0,0 +1,28 @@
+from pathlib import Path
+
+
+def show(name):
+    """Print the source code of a practical by its keyword."""
+
+    if not isinstance(name, str) or not name.strip():
+        raise ValueError("Please provide a practical name, e.g. show('caesar').")
+
+    name = name.strip().lower()
+    codes_dir = Path(__file__).parent / "codes"
+
+    matches = [
+        file
+        for file in codes_dir.rglob("*.py")
+        if file.stem.lower() == name
+    ]
+
+    if not matches:
+        print(f"Practical '{name}' was not found.")
+        return
+
+    if len(matches) > 1:
+        print(f"Multiple practicals named '{name}' were found.")
+        return
+
+    source = matches[0].read_text(encoding="utf-8")
+    print(source, end="" if source.endswith("\n") else "\n")

aunties-0.1.0/src/aunties.egg-info/PKG-INFO

@@ -0,0 +1,120 @@
+Metadata-Version: 2.4
+Name: aunties
+Version: 0.1.0
+Summary: A simple library for displaying AI and Cybersecurity practical source code
+Author: Aunties Contributors
+License-Expression: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# Aunties — Python Practical Code Library
+
+Aunties is a simple, free Python library that provides source code for practical programs from two subjects:
+
+- **Artificial Intelligence (AI)**
+- **Cyber and Information Security (CIS)**
+
+The library allows users to display the complete source code of a practical directly in the terminal using a simple Python function.
+
+## Features
+
+- Stores practical programs organized by subject.
+- Displays source code using a simple keyword.
+- Preserves indentation, blank lines, and code formatting.
+- Supports adding new practicals without modifying the main function.
+- Open-source and designed for students and learners.
+
+## Installation
+
+Install the library using pip:
+
+```bash
+pip install aunties
+```
+
+*Note: This command will work once the package has been published on PyPI. To install the project before publication, see the Development section.*
+
+## Usage
+
+Import the `show` function:
+
+```python
+from aunties import show
+```
+
+Display a practical by passing its keyword:
+
+```python
+show("caesar")
+```
+
+Display another practical:
+
+```python
+show("rsa")
+```
+
+The library prints the complete source code of the selected practical in the terminal.
+
+## Available Practicals
+
+Practical keywords are based on their filenames without the `.py` extension.
+
+| Subject | Filename | Keyword |
+|---|---|---|
+| Cyber and Information Security | `caesar.py` | `caesar` |
+| Cyber and Information Security | `rsa.py` | `rsa` |
+| Artificial Intelligence | `bfs.py` | `bfs` |
+| Artificial Intelligence | `minimax.py` | `minimax` |
+
+The table shows examples. Actual availability depends on the practical files included in the installed version.
+
+## Project Structure
+
+```text
+aunties/
+├── pyproject.toml
+├── README.md
+└── src/
+    └── aunties/
+        ├── __init__.py
+        ├── show.py
+        └── codes/
+            ├── ai/
+            └── cis/
+```
+
+## Adding a New Practical
+
+1. Open the appropriate subject folder inside `codes/`.
+2. Create a Python file, such as `vigenere.py`.
+3. Add the practical's source code to that file.
+4. Use its filename as the keyword:
+
+```python
+show("vigenere")
+```
+
+No changes to `show.py` are required when adding a uniquely named practical.
+
+## Development
+
+To install the project locally in editable mode, clone or download the repository, navigate to its root directory, and run:
+
+```bash
+python -m pip install -e .
+```
+
+You can then import and test the library in your Python scripts.
+
+## Important Note
+
+Aunties displays source code as text. It does not execute the displayed practical or perform encryption, decryption, or AI operations automatically.
+
+## Contributing
+
+Contributions are welcome. You can help by adding practical programs, improving documentation, fixing bugs, or suggesting improvements.
+
+## License
+
+This project is intended to be open-source. The

aunties-0.1.0/src/aunties.egg-info/SOURCES.txt

@@ -0,0 +1,27 @@
+README.md
+pyproject.toml
+src/aunties/__init__.py
+src/aunties/show.py
+src/aunties.egg-info/PKG-INFO
+src/aunties.egg-info/SOURCES.txt
+src/aunties.egg-info/dependency_links.txt
+src/aunties.egg-info/top_level.txt
+src/aunties/codes/ai/Adaboost.py
+src/aunties/codes/ai/Astar.py
+src/aunties/codes/ai/BFS.py
+src/aunties/codes/ai/Back.py
+src/aunties/codes/ai/Bayes.py
+src/aunties/codes/ai/Dtree.py
+src/aunties/codes/ai/KNN.py
+src/aunties/codes/ai/Mining.py
+src/aunties/codes/ai/Open.py
+src/aunties/codes/ai/RBFS.py
+src/aunties/codes/ai/SVM.py
+src/aunties/codes/cis/TLS.py
+src/aunties/codes/cis/ceasar.py
+src/aunties/codes/cis/fence.py
+src/aunties/codes/cis/hellman.py
+src/aunties/codes/cis/hmac.py
+src/aunties/codes/cis/ids.py
+src/aunties/codes/cis/pss.py
+src/aunties/codes/cis/rsa.py

aunties-0.1.0/src/aunties.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

aunties-0.1.0/src/aunties.egg-info/top_level.txt

@@ -0,0 +1 @@
+aunties