ai-practical-kit 1.1.0__py3-none-any.whl

ai_practical_kit/__init__.py

@@ -0,0 +1,22 @@
+"""AIPracticalKit: reusable, beginner-friendly AI practical algorithms."""
+
+from .experiments.vacuum_cleaner import solve_vacuum
+from .experiments.astar_8_puzzle import solve_astar, heuristic
+from .experiments.alpha_beta_pruning import solve_alpha_beta
+from .experiments.tower_of_hanoi_bfs import solve_hanoi_bfs
+from .experiments.sudoku_solver import solve_sudoku
+from .experiments.local_beam_tsp import local_beam_tsp, tour_cost
+from .experiments.robot_path_bfs import solve_robot_bfs
+from .experiments.maze_dfs import solve_maze_dfs
+from .experiments.eight_queens import solve_8_queens
+from .experiments.rule_chatbot import respond
+from .experiments.tictactoe_minimax import find_best_move, minimax
+
+__version__ = "1.1.0"
+
+__all__ = [
+    "solve_vacuum", "solve_astar", "heuristic", "solve_alpha_beta",
+    "solve_hanoi_bfs", "solve_sudoku", "local_beam_tsp", "tour_cost",
+    "solve_robot_bfs", "solve_maze_dfs", "solve_8_queens", "respond",
+    "find_best_move", "minimax",
+]

ai_practical_kit/cli.py

@@ -0,0 +1,157 @@
+"""Text menu for running and inspecting AIPracticalKit experiments."""
+
+import importlib
+from pathlib import Path
+import shutil
+import subprocess
+import sys
+
+SOURCE_DIR = Path(__file__).resolve().parent / "experiments"
+
+EXPERIMENTS = [
+    (1, "Simple Reflex Agent - Vacuum Cleaner", "vacuum_cleaner.py", "vacuum_cleaner"),
+    (2, "A* Search - 8-Puzzle", "astar_8_puzzle.py", "astar_8_puzzle"),
+    (3, "Alpha-Beta Pruning", "alpha_beta_pruning.py", "alpha_beta_pruning"),
+    (4, "Tower of Hanoi using BFS", "tower_of_hanoi_bfs.py", "tower_of_hanoi_bfs"),
+    (5, "Sudoku - Constraint Propagation and Backtracking", "sudoku_solver.py", "sudoku_solver"),
+    (6, "Local Beam Search - TSP", "local_beam_tsp.py", "local_beam_tsp"),
+    (7, "BFS - Robot Path Planning", "robot_path_bfs.py", "robot_path_bfs"),
+    (8, "DFS - Maze Solving", "maze_dfs.py", "maze_dfs"),
+    (9, "8-Queens using Backtracking", "eight_queens.py", "eight_queens"),
+    (10, "Rule-Based Chatbot - Regex and AND", "rule_chatbot.py", "rule_chatbot"),
+    (11, "Tic-Tac-Toe using Minimax", "tictactoe_minimax.py", "tictactoe_minimax"),
+]
+
+
+def _select_experiment():
+    print("\nAI PRACTICAL KIT - EXPERIMENTS")
+    for number, title, _, _ in EXPERIMENTS:
+        print(str(number) + ". " + title)
+    try:
+        number = int(input("Experiment number (0 to cancel): ").strip())
+    except ValueError:
+        print("Please enter a number.")
+        return None
+    if number == 0:
+        return None
+    for item in EXPERIMENTS:
+        if item[0] == number:
+            return item
+    print("Invalid experiment number.")
+    return None
+
+
+def _open_editor(path):
+    editor = shutil.which("code")
+    try:
+        if editor:
+            subprocess.Popen([editor, "--reuse-window", str(path)])
+        elif sys.platform.startswith("win"):
+            subprocess.Popen(["notepad.exe", str(path)])
+        elif sys.platform == "darwin":
+            subprocess.Popen(["open", "-t", str(path)])
+        else:
+            opener = shutil.which("xdg-open")
+            if opener:
+                subprocess.Popen([opener, str(path)])
+            else:
+                print("Open this source in your editor:\n" + str(path))
+                return
+        print("Opened source:", path.name)
+    except OSError as error:
+        print("Could not open the editor:", error)
+        print("Source file:", path)
+
+
+def _copy_source(path):
+    source = path.read_text(encoding="utf-8")
+    commands = []
+    if sys.platform.startswith("win"):
+        commands.append(["clip"])
+    elif sys.platform == "darwin":
+        commands.append(["pbcopy"])
+    else:
+        commands.extend([["wl-copy"], ["xclip", "-selection", "clipboard"],
+                         ["xsel", "--clipboard", "--input"]])
+
+    for command in commands:
+        if shutil.which(command[0]):
+            try:
+                subprocess.run(command, input=source, text=True, check=True)
+                print("Copied source to clipboard:", path.name)
+                return
+            except (OSError, subprocess.CalledProcessError):
+                pass
+
+    try:
+        import tkinter
+        window = tkinter.Tk()
+        window.withdraw()
+        window.clipboard_clear()
+        window.clipboard_append(source)
+        window.update()
+        window.destroy()
+        print("Copied source to clipboard:", path.name)
+    except Exception:
+        print("Clipboard copy is unavailable. Open this source and copy it manually:")
+        print(path)
+
+
+def main():
+    """Run the installed text menu."""
+    while True:
+        print("\n" + "=" * 60)
+        print("                AI PRACTICAL KIT")
+        print("       Run algorithms or inspect full source code")
+        print("=" * 60)
+        print("1. Run an experiment")
+        print("2. View full source code")
+        print("3. Open source in an editor")
+        print("4. Copy source code")
+        print("5. Show import examples")
+        print("0. Exit")
+        choice = input("Choose an option: ").strip()
+
+        if choice == "0":
+            print("Good luck with your practical examinations!")
+            return
+
+        if choice == "5":
+            print("\nfrom ai_practical_kit import solve_astar")
+            print('result = solve_astar("123406758")')
+            print('print(result["path"])')
+            print("\nfrom ai_practical_kit import solve_8_queens")
+            print("result = solve_8_queens()")
+            print('print(result["total_solutions"])')
+            print("\nfrom ai_practical_kit import respond")
+            print('print(respond("Tell me about admission and fees"))')
+            continue
+
+        item = _select_experiment()
+        if item is None:
+            continue
+        number, title, filename, module_name = item
+        path = SOURCE_DIR / filename
+
+        if choice == "1":
+            module = importlib.import_module("ai_practical_kit.experiments." + module_name)
+            try:
+                module.run_cli()
+            except (KeyboardInterrupt, EOFError):
+                print("\nExperiment cancelled.")
+        elif choice == "2":
+            print("\n" + "=" * 72)
+            print(title + " — FULL SOURCE")
+            print("=" * 72)
+            print(path.read_text(encoding="utf-8"))
+            print("=" * 72)
+        elif choice == "3":
+            _open_editor(path)
+        elif choice == "4":
+            _copy_source(path)
+        else:
+            print("Invalid choice. Choose 0 to 5.")
+
+
+if __name__ == "__main__":
+    main()

ai_practical_kit/experiments/alpha_beta_pruning.py

@@ -0,0 +1,91 @@
+"""Experiment 3: Alpha-Beta Pruning on a depth-3 binary game tree."""
+
+INFINITY = 10**9
+DEFAULT_LEAVES = [3, 5, 6, 9, 1, 2, 0, -1]
+INTERNAL_NAMES = "ABCDEFG"
+
+
+def solve_alpha_beta(leaf_values=None):
+    """Return minimax value, root branch, evaluated leaves and pruned branches."""
+    if leaf_values is None:
+        leaf_values = DEFAULT_LEAVES[:]
+    leaf_values = list(leaf_values)
+    if len(leaf_values) != 8:
+        raise ValueError("Enter exactly 8 leaf values.")
+
+    evaluated = 0
+    pruned = []
+    best_root_branch = None
+
+    def node_name(node_index):
+        if node_index < 7:
+            return INTERNAL_NAMES[node_index]
+        return str(leaf_values[node_index - 7])
+
+    def search(node, depth, is_max, alpha, beta):
+        nonlocal evaluated, best_root_branch
+
+        if depth == 3:
+            evaluated += 1
+            return leaf_values[node - 7]
+
+        if is_max:
+            best = -INFINITY
+        else:
+            best = INFINITY
+
+        for child_number in range(2):
+            child = 2 * node + 1 + child_number
+            score = search(child, depth + 1, not is_max, alpha, beta)
+
+            if is_max:
+                if score > best:
+                    best = score
+                    if node == 0:
+                        best_root_branch = node_name(child)
+                if best > alpha:
+                    alpha = best
+            else:
+                if score < best:
+                    best = score
+                if best < beta:
+                    beta = best
+
+            if alpha >= beta:
+                if child_number == 0:
+                    skipped = 2 * node + 2
+                    if depth + 1 == 3:
+                        pruned.append("leaf " + node_name(skipped))
+                    else:
+                        pruned.append("subtree " + node_name(skipped))
+                break
+
+        return best
+
+    value = search(0, 0, True, -INFINITY, INFINITY)
+    return {"value": value, "best_branch": best_root_branch,
+            "leaves_evaluated": evaluated, "pruned": pruned,
+            "leaf_values": leaf_values}
+
+
+def run_cli():
+    print("\nEXPERIMENT 3: ALPHA-BETA PRUNING")
+    print("Enter 8 leaf values from left to right, or press Enter for the practical example.")
+    raw = input("Leaf values [3 5 6 9 1 2 0 -1]: ").strip()
+    try:
+        values = DEFAULT_LEAVES if raw == "" else [int(x) for x in raw.split()]
+        result = solve_alpha_beta(values)
+    except ValueError as error:
+        print("Input error:", error)
+        return
+    print("Minimax value at root:", result["value"])
+    print("Best branch for MAX:", result["best_branch"])
+    print("Leaves evaluated:", result["leaves_evaluated"], "out of 8")
+    if result["pruned"]:
+        print("Pruned:", ", ".join(result["pruned"]))
+    else:
+        print("Pruned: none")
+
+
+if __name__ == "__main__":
+    run_cli()

ai_practical_kit/experiments/astar_8_puzzle.py

@@ -0,0 +1,116 @@
+"""Experiment 2: A* Search for the 8-Puzzle using Manhattan distance."""
+
+import heapq
+
+GOAL = "123456780"
+
+
+def heuristic(state):
+    """Sum of Manhattan distances; the blank ('0') is ignored."""
+    distance = 0
+    for index in range(9):
+        if state[index] != "0":
+            goal_index = int(state[index]) - 1
+            distance += abs(index // 3 - goal_index // 3)
+            distance += abs(index % 3 - goal_index % 3)
+    return distance
+
+
+def is_solvable(state):
+    """For a 3x3 puzzle, the inversion count must be even."""
+    numbers = [int(ch) for ch in state if ch != "0"]
+    inversions = 0
+    for i in range(len(numbers)):
+        for j in range(i + 1, len(numbers)):
+            if numbers[i] > numbers[j]:
+                inversions += 1
+    return inversions % 2 == 0
+
+
+def solve_astar(start):
+    """Solve a valid 8-puzzle string. Return path, moves and expanded count."""
+    start = "".join(str(x) for x in start) if not isinstance(start, str) else start.strip().replace(" ", "")
+    if len(start) != 9 or sorted(start) != list("012345678"):
+        raise ValueError("State must contain digits 0 through 8 exactly once.")
+    if not is_solvable(start):
+        return {"found": False, "path": [], "moves": None, "expanded": 0}
+
+    # Entries are (f, g, state); smallest f is removed first.
+    open_queue = []
+    heapq.heappush(open_queue, (heuristic(start), 0, start))
+    best_g = {start: 0}
+    parent = {start: None}
+    expanded = 0
+    directions = [(-1, 0), (1, 0), (0, -1), (0, 1)]
+
+    while open_queue:
+        f, current_g, current = heapq.heappop(open_queue)
+        if current_g != best_g.get(current):
+            continue  # An older, worse queue entry.
+
+        expanded += 1
+        if current == GOAL:
+            path = []
+            state = current
+            while state is not None:
+                path.append(state)
+                state = parent[state]
+            path.reverse()
+            return {"found": True, "path": path, "moves": len(path) - 1,
+                    "expanded": expanded}
+
+        blank = current.index("0")
+        row = blank // 3
+        col = blank % 3
+
+        for dr, dc in directions:
+            nr = row + dr
+            nc = col + dc
+            if nr < 0 or nr >= 3 or nc < 0 or nc >= 3:
+                continue
+
+            new_blank = nr * 3 + nc
+            chars = list(current)
+            chars[blank], chars[new_blank] = chars[new_blank], chars[blank]
+            next_state = "".join(chars)
+            new_g = current_g + 1
+
+            if new_g < best_g.get(next_state, 10**9):
+                best_g[next_state] = new_g
+                parent[next_state] = current
+                heapq.heappush(open_queue,
+                               (new_g + heuristic(next_state), new_g, next_state))
+
+    return {"found": False, "path": [], "moves": None, "expanded": expanded}
+
+
+def print_board(state):
+    for i in range(9):
+        print(("_" if state[i] == "0" else state[i]), end=" ")
+        if i % 3 == 2:
+            print()
+
+
+def run_cli():
+    print("\nEXPERIMENT 2: A* SEARCH FOR 8-PUZZLE")
+    raw = input("Enter 9 digits (0 = blank), e.g. 1 2 3 4 0 6 7 5 8: ")
+    start = "".join(raw.split())
+    try:
+        result = solve_astar(start)
+    except ValueError as error:
+        print("Input error:", error)
+        return
+    if not result["found"]:
+        print("No solution exists for this puzzle.")
+        return
+    print("\nSolution path:")
+    for step, state in enumerate(result["path"]):
+        print("\nStep", step, "(g =", step, ", h =", heuristic(state),
+              ", f =", step + heuristic(state), ")")
+        print_board(state)
+    print("Number of moves:", result["moves"])
+    print("Nodes expanded:", result["expanded"])
+
+
+if __name__ == "__main__":
+    run_cli()

ai_practical_kit/experiments/eight_queens.py

@@ -0,0 +1,62 @@
+"""Experiment 9: Backtracking for the 8-Queens constraint problem."""
+
+SIZE = 8
+
+
+def solve_8_queens():
+    """Return the first solution and total number of solutions (92)."""
+    board = [-1] * SIZE
+    first_solution = None
+    solution_count = 0
+
+    def is_safe(row, col):
+        for previous_row in range(row):
+            if board[previous_row] == col:
+                return False
+            if abs(board[previous_row] - col) == abs(previous_row - row):
+                return False
+        return True
+
+    def solve(row):
+        nonlocal first_solution, solution_count
+        if row == SIZE:
+            solution_count += 1
+            if first_solution is None:
+                first_solution = board[:]
+            return
+
+        for col in range(SIZE):
+            if is_safe(row, col):
+                board[row] = col
+                solve(row + 1)
+                board[row] = -1  # Backtrack and try another column.
+
+    solve(0)
+    return {"solution": first_solution, "total_solutions": solution_count}
+
+
+def run_cli():
+    print("\nEXPERIMENT 9: 8-QUEENS USING BACKTRACKING")
+    result = solve_8_queens()
+    board = result["solution"]
+    if board is None:
+        print("No solution exists.")
+        return
+
+    print("First solution (Q = queen, . = empty):")
+    for row in range(SIZE):
+        for col in range(SIZE):
+            if board[row] == col:
+                print("Q", end=" ")
+            else:
+                print(".", end=" ")
+        print()
+
+    print("Queen positions (row, column; numbering starts at 1):")
+    for row in range(SIZE):
+        print("Queen", row + 1, ": (", row + 1, ", ", board[row] + 1, ")", sep="")
+    print("Total solutions:", result["total_solutions"])
+
+
+if __name__ == "__main__":
+    run_cli()

ai_practical_kit/experiments/local_beam_tsp.py

@@ -0,0 +1,116 @@
+"""Experiment 6: Local Beam Search for the Traveling Salesman Problem."""
+
+import itertools
+import math
+import random
+
+
+def tour_cost(tour, distance):
+    """Total cost of a tour, including the return to city 0."""
+    total = 0
+    n = len(tour)
+    for i in range(n - 1):
+        total += distance[tour[i]][tour[i + 1]]
+    total += distance[tour[-1]][tour[0]]
+    return total
+
+
+def local_beam_tsp(distance, beam_width=3, max_iterations=20, seed=42):
+    """Return the best tour found by Local Beam Search.
+
+    City 0 is fixed at the beginning of each tour. `distance` is a square matrix.
+    """
+    n = len(distance)
+    if n < 3 or any(len(row) != n for row in distance):
+        raise ValueError("Distance matrix must be square and contain at least 3 cities.")
+    if beam_width < 1 or max_iterations < 1:
+        raise ValueError("Beam width and iterations must both be at least 1.")
+    if any(distance[i][j] < 0 for i in range(n) for j in range(n)):
+        raise ValueError("Distances cannot be negative.")
+
+    beam_width = min(beam_width, math.factorial(n - 1))
+    rng = random.Random(seed)
+    city_list = list(range(1, n))
+    beam = []
+    seen = set()
+
+    # Create distinct initial tours in a repeatable random order.
+    attempts = 0
+    while len(beam) < beam_width and attempts < beam_width * 50:
+        rng.shuffle(city_list)
+        tour = tuple([0] + city_list[:])
+        if tour not in seen:
+            seen.add(tour)
+            beam.append(tour)
+        attempts += 1
+
+    # Fill any remaining slots systematically (small practical inputs).
+    if len(beam) < beam_width:
+        for order in itertools.permutations(range(1, n)):
+            tour = tuple([0] + list(order))
+            if tour not in seen:
+                seen.add(tour)
+                beam.append(tour)
+            if len(beam) == beam_width:
+                break
+
+    best_tour = min(beam, key=lambda tour: tour_cost(tour, distance))
+    best_cost = tour_cost(best_tour, distance)
+    history = [best_cost]
+
+    for _ in range(max_iterations):
+        candidates = {}
+        for tour in beam:
+            for i in range(1, n - 1):
+                for j in range(i + 1, n):
+                    neighbour = list(tour)
+                    neighbour[i], neighbour[j] = neighbour[j], neighbour[i]
+                    neighbour = tuple(neighbour)
+                    candidates[neighbour] = tour_cost(neighbour, distance)
+
+        if not candidates:
+            break
+
+        ordered = sorted(candidates.items(), key=lambda item: (item[1], item[0]))
+        next_beam = [tour for tour, cost_value in ordered[:beam_width]]
+        beam = next_beam
+
+        if ordered[0][1] < best_cost:
+            best_tour = ordered[0][0]
+            best_cost = ordered[0][1]
+        history.append(best_cost)
+
+    return {"tour": list(best_tour), "cost": best_cost,
+            "iterations": len(history) - 1, "best_cost_history": history}
+
+
+def run_cli():
+    print("\nEXPERIMENT 6: LOCAL BEAM SEARCH FOR TSP")
+    try:
+        n = int(input("Enter number of cities (3-10 recommended): "))
+        if n < 3 or n > 10:
+            raise ValueError("Use between 3 and 10 cities for this practical.")
+        distance = []
+        print("Enter the distance matrix, one row per line:")
+        for _ in range(n):
+            row = [float(x) for x in input().split()]
+            if len(row) != n:
+                raise ValueError("Each distance row must contain exactly n values.")
+            distance.append(row)
+        beam_width = int(input("Enter beam width K: "))
+        iterations = int(input("Enter maximum iterations: "))
+        result = local_beam_tsp(distance, beam_width, iterations)
+    except ValueError as error:
+        print("Input error:", error)
+        return
+
+    tour = result["tour"]
+    print("\nBest tour found:")
+    print(" -> ".join(str(city) for city in tour + [tour[0]]))
+    print("Best tour cost:", round(result["cost"], 3))
+    print("Iterations completed:", result["iterations"])
+    print("Note: Local Beam Search is heuristic and does not guarantee the global optimum.")
+
+
+if __name__ == "__main__":
+    run_cli()

ai_practical_kit/experiments/maze_dfs.py

@@ -0,0 +1,92 @@
+"""Experiment 8: DFS for Maze Solving."""
+
+
+def solve_maze_dfs(maze):
+    """Find a path from S to E by DFS; return path and a marked maze."""
+    if not maze or not maze[0]:
+        raise ValueError("Maze cannot be empty.")
+    rows = len(maze)
+    cols = len(maze[0])
+    if any(len(row) != cols for row in maze):
+        raise ValueError("All maze rows must have the same length.")
+
+    start = None
+    goal = None
+    for r in range(rows):
+        for c in range(cols):
+            if maze[r][c] == "S":
+                if start is not None:
+                    raise ValueError("Maze must contain exactly one S.")
+                start = (r, c)
+            elif maze[r][c] == "E":
+                if goal is not None:
+                    raise ValueError("Maze must contain exactly one E.")
+                goal = (r, c)
+    if start is None or goal is None:
+        raise ValueError("Maze must contain one S (start) and one E (exit).")
+
+    visited = set()
+    path = []
+    # Same order as the practical: Right, Down, Left, Up.
+    directions = [(0, 1), (1, 0), (0, -1), (-1, 0)]
+
+    def dfs(r, c):
+        if r < 0 or r >= rows or c < 0 or c >= cols:
+            return False
+        if maze[r][c] == "#" or (r, c) in visited:
+            return False
+
+        visited.add((r, c))
+        path.append((r, c))
+        if (r, c) == goal:
+            return True
+
+        for dr, dc in directions:
+            if dfs(r + dr, c + dc):
+                return True
+
+        path.pop()  # Dead end: remove this cell from the current path.
+        return False
+
+    found = dfs(start[0], start[1])
+    if not found:
+        return {"found": False, "path": [], "maze": list(maze),
+                "visited_count": len(visited)}
+
+    marked = [list(row) for row in maze]
+    for r, c in path:
+        if marked[r][c] == ".":
+            marked[r][c] = "*"
+    return {"found": True, "path": path,
+            "maze": ["".join(row) for row in marked],
+            "visited_count": len(visited)}
+
+
+def run_cli():
+    print("\nEXPERIMENT 8: DFS MAZE SOLVER")
+    try:
+        rows, cols = [int(x) for x in input("Enter rows and columns: ").split()]
+        if rows < 1 or cols < 1 or rows > 50 or cols > 50:
+            raise ValueError("Rows and columns must be between 1 and 50.")
+        print("Enter each maze row using S=start, E=exit, #=wall, .=free:")
+        maze = [input().strip() for _ in range(rows)]
+        if any(len(row) != cols for row in maze):
+            raise ValueError("Each row must contain exactly the given number of columns.")
+        result = solve_maze_dfs(maze)
+    except ValueError as error:
+        print("Input error:", error)
+        return
+
+    if not result["found"]:
+        print("No path exists in the maze.")
+        return
+    print("\nPath found (DFS does not guarantee shortest path):")
+    for r, c in result["path"]:
+        print("(" + str(r + 1) + "," + str(c + 1) + ")", end=" ")
+    print("\n\nMaze with path:")
+    for row in result["maze"]:
+        print(" ".join(row))
+
+
+if __name__ == "__main__":
+    run_cli()