cosc604 0.1.0__tar.gz

cosc604-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019-2026 Andreas Henschel
+
+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.

cosc604-0.1.0/PKG-INFO

@@ -0,0 +1,93 @@
+Metadata-Version: 2.4
+Name: cosc604
+Version: 0.1.0
+Summary: Teaching implementations of search algorithms (BFS, DFS, UCS, A*) from Russell & Norvig's Artificial Intelligence: A Modern Approach, developed for COSC604.
+Author-email: Andreas Henschel <andreas.henschel@ku.ac.ae>
+License: MIT
+Keywords: artificial-intelligence,search,aima,education,russell-norvig
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Education
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Education
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: networkx
+Provides-Extra: plot
+Requires-Dist: matplotlib; extra == "plot"
+Dynamic: license-file
+
+# cosc604
+
+Teaching code for **COSC604 – Techniques in Artificial Intelligence**,
+developed alongside Assignment 1 (instructor: Andreas Henschel,
+andreas.henschel@ku.ac.ae). It implements the generic search infrastructure
+from Russell & Norvig, *Artificial Intelligence: A Modern Approach* (Ch. 3):
+fringes/queues, the search-tree `Node`, `graph_search`/`tree_search`, and the
+standard strategies built on top of them (BFS, DFS, uniform-cost, A*).
+
+`Assignment1.ipynb` walks through the same code interactively, with the
+routing-problem and tile-puzzle exercises described there. The modules under
+`src/cosc604/` are the packaged, importable version of that code.
+
+## Package layout
+
+| Module | Contents |
+| --- | --- |
+| `cosc604.searches` | `Fringe`, `FIFO`, `LIFO`, `PriorityQueue`, `Node`, `graph_search`, `tree_search`, and the convenience wrappers `breadth_first_graph_search`, `depth_first_graph_search`, `depth_first_tree_search`, `astar_graph_search`, `uniform_cost_search`. |
+| `cosc604.priority_queue_demo` | Standalone examples of how `PriorityQueue`'s priority function `f` shapes ordering (digit-sum, "VIP title" count). Run with `python -m cosc604.priority_queue_demo`. |
+| `cosc604.graph_problem` | `GraphProblem` — the routing problem from the lecture slides, built on `networkx`. Includes the toy example and the Romania map. |
+| `cosc604.puzzle_problem` | `PuzzleProblem` / `PuzzleState` — the sliding tile puzzle (8-puzzle for `size=3`). `PuzzleState.successors`, `__hash__` and `__eq__` are left as an exercise — implement them to make the puzzle searchable. |
+
+## Installation
+
+From PyPI:
+
+```bash
+pip install cosc604
+```
+
+Or, from this directory, as an editable install:
+
+```bash
+pip install -e .
+```
+
+This pulls in `numpy` and `networkx`. To also plot the Romania graph
+(`graph_problem.draw_romania()`), install the optional `plot` extra:
+
+```bash
+pip install "cosc604[plot]"
+```
+
+## Quickstart
+
+```python
+from cosc604 import GraphProblem, uniform_cost_search
+
+connections = [('S', 'A', 5), ('S', 'B', 3), ('S', 'C', 1),
+               ('A', 'G', 1), ('B', 'G', 2), ('C', 'G', 17)]
+toy = GraphProblem('S', 'G', connections, directed=True)
+
+solution = uniform_cost_search(toy)
+print([(node.state, node.action) for node in solution.getPath()])
+```
+
+## Assignment
+
+Assignment 1 asks you to:
+
+1. Add a `LIFO` fringe and complete the generic search algorithms (both done
+   here) — read through `searches.py` to understand how `graph_search` and
+   `tree_search` use a `Fringe` to implement each strategy.
+2. Implement `PuzzleState.successors`, `__hash__` and `__eq__` in
+   `puzzle_problem.py` so `PuzzleProblem` can be solved with the same search
+   algorithms used for the routing problem, and reproduce the tile-puzzle
+   results shown in the slides (`tileslides.png`).
+
+## License
+
+MIT — see [LICENSE](LICENSE).

cosc604-0.1.0/README.md

@@ -0,0 +1,71 @@
+# cosc604
+
+Teaching code for **COSC604 – Techniques in Artificial Intelligence**,
+developed alongside Assignment 1 (instructor: Andreas Henschel,
+andreas.henschel@ku.ac.ae). It implements the generic search infrastructure
+from Russell & Norvig, *Artificial Intelligence: A Modern Approach* (Ch. 3):
+fringes/queues, the search-tree `Node`, `graph_search`/`tree_search`, and the
+standard strategies built on top of them (BFS, DFS, uniform-cost, A*).
+
+`Assignment1.ipynb` walks through the same code interactively, with the
+routing-problem and tile-puzzle exercises described there. The modules under
+`src/cosc604/` are the packaged, importable version of that code.
+
+## Package layout
+
+| Module | Contents |
+| --- | --- |
+| `cosc604.searches` | `Fringe`, `FIFO`, `LIFO`, `PriorityQueue`, `Node`, `graph_search`, `tree_search`, and the convenience wrappers `breadth_first_graph_search`, `depth_first_graph_search`, `depth_first_tree_search`, `astar_graph_search`, `uniform_cost_search`. |
+| `cosc604.priority_queue_demo` | Standalone examples of how `PriorityQueue`'s priority function `f` shapes ordering (digit-sum, "VIP title" count). Run with `python -m cosc604.priority_queue_demo`. |
+| `cosc604.graph_problem` | `GraphProblem` — the routing problem from the lecture slides, built on `networkx`. Includes the toy example and the Romania map. |
+| `cosc604.puzzle_problem` | `PuzzleProblem` / `PuzzleState` — the sliding tile puzzle (8-puzzle for `size=3`). `PuzzleState.successors`, `__hash__` and `__eq__` are left as an exercise — implement them to make the puzzle searchable. |
+
+## Installation
+
+From PyPI:
+
+```bash
+pip install cosc604
+```
+
+Or, from this directory, as an editable install:
+
+```bash
+pip install -e .
+```
+
+This pulls in `numpy` and `networkx`. To also plot the Romania graph
+(`graph_problem.draw_romania()`), install the optional `plot` extra:
+
+```bash
+pip install "cosc604[plot]"
+```
+
+## Quickstart
+
+```python
+from cosc604 import GraphProblem, uniform_cost_search
+
+connections = [('S', 'A', 5), ('S', 'B', 3), ('S', 'C', 1),
+               ('A', 'G', 1), ('B', 'G', 2), ('C', 'G', 17)]
+toy = GraphProblem('S', 'G', connections, directed=True)
+
+solution = uniform_cost_search(toy)
+print([(node.state, node.action) for node in solution.getPath()])
+```
+
+## Assignment
+
+Assignment 1 asks you to:
+
+1. Add a `LIFO` fringe and complete the generic search algorithms (both done
+   here) — read through `searches.py` to understand how `graph_search` and
+   `tree_search` use a `Fringe` to implement each strategy.
+2. Implement `PuzzleState.successors`, `__hash__` and `__eq__` in
+   `puzzle_problem.py` so `PuzzleProblem` can be solved with the same search
+   algorithms used for the routing problem, and reproduce the tile-puzzle
+   results shown in the slides (`tileslides.png`).
+
+## License
+
+MIT — see [LICENSE](LICENSE).

cosc604-0.1.0/pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "cosc604"
+version = "0.1.0"
+description = "Teaching implementations of search algorithms (BFS, DFS, UCS, A*) from Russell & Norvig's Artificial Intelligence: A Modern Approach, developed for COSC604."
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "MIT" }
+authors = [
+    { name = "Andreas Henschel", email = "andreas.henschel@ku.ac.ae" },
+]
+keywords = ["artificial-intelligence", "search", "aima", "education", "russell-norvig"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Education",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Topic :: Education",
+]
+dependencies = [
+    "numpy",
+    "networkx",
+]
+
+[project.optional-dependencies]
+plot = ["matplotlib"]
+
+[tool.setuptools.packages.find]
+where = ["src"]

cosc604-0.1.0/setup.cfg

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

cosc604-0.1.0/src/cosc604/__init__.py

@@ -0,0 +1,22 @@
+"""cosc604: teaching implementations of the search algorithms from
+Russell & Norvig, *Artificial Intelligence: A Modern Approach* (Ch. 3),
+developed for COSC604 - Techniques in Artificial Intelligence.
+"""
+from .searches import (
+    Fringe, FIFO, LIFO, PriorityQueue, Node,
+    graph_search, tree_search,
+    breadth_first_graph_search, depth_first_graph_search,
+    depth_first_tree_search, astar_graph_search, uniform_cost_search,
+)
+from .graph_problem import GraphProblem
+from .puzzle_problem import PuzzleProblem, PuzzleState
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "Fringe", "FIFO", "LIFO", "PriorityQueue", "Node",
+    "graph_search", "tree_search",
+    "breadth_first_graph_search", "depth_first_graph_search",
+    "depth_first_tree_search", "astar_graph_search", "uniform_cost_search",
+    "GraphProblem", "PuzzleProblem", "PuzzleState",
+]

cosc604-0.1.0/src/cosc604/graph_problem.py

@@ -0,0 +1,69 @@
+"""The Routing problem from the textbook: states are cities, actions move
+along weighted edges of a graph. GraphProblem plugs into the generic
+searches.py algorithms via the successors/goal_test interface.
+
+Run directly with: python -m cosc604.graph_problem
+"""
+import networkx as nx
+
+from .searches import uniform_cost_search
+
+
+class GraphProblem:
+    def __init__(self, initial, goal, connections, locations=None, directed=False):
+        self.initial = initial
+        self.goal = goal
+        self.locations = locations
+        self.graph = nx.DiGraph() if directed else nx.Graph()
+        for cityA, cityB, distance in connections:
+            self.graph.add_edge(cityA, cityB, cost=distance)
+
+    def successors(self, state):
+        # Exactly as defined in Lecture slides
+        return [("go to %s" % city, connection['cost'], city)
+                for city, connection in self.graph[state].items()]
+
+    def goal_test(self, state):
+        return state == self.goal
+
+
+# ---------------------------------------------------------------------------
+# Warm up: the little toy example from the slides
+# ---------------------------------------------------------------------------
+
+toyConnections = [('S', 'A', 5), ('S', 'B', 3), ('S', 'C', 1),
+                   ('A', 'G', 1), ('B', 'G', 2), ('C', 'G', 17)]
+toy = GraphProblem('S', 'G', toyConnections, directed=True)
+
+
+# ---------------------------------------------------------------------------
+# Romania: the classic bigger example. Try different initial/goal states.
+# ---------------------------------------------------------------------------
+
+connections = [('A', 'S', 140), ('A', 'Z', 75), ('A', 'T', 118), ('C', 'P', 138), ('C', 'R', 146), ('C', 'D', 120),
+               ('B', 'P', 101), ('B', 'U', 85), ('B', 'G', 90), ('B', 'F', 211), ('E', 'H', 86), ('D', 'M', 75),
+               ('F', 'S', 99), ('I', 'V', 92), ('I', 'N', 87), ('H', 'U', 98), ('L', 'M', 70), ('L', 'T', 111),
+               ('O', 'S', 151), ('O', 'Z', 71), ('P', 'R', 97), ('R', 'S', 80), ('U', 'V', 142)]
+
+locations = {'A': (91, 492), 'C': (253, 288), 'B': (400, 327), 'E': (562, 293), 'D': (165, 299), 'G': (375, 270), 'F': (305, 449),
+             'I': (473, 506), 'H': (534, 350), 'M': (168, 339), 'L': (165, 379), 'O': (131, 571), 'N': (406, 537), 'P': (320, 368),
+             'S': (207, 457), 'R': (233, 410), 'U': (456, 350), 'T': (94, 410), 'V': (509, 444), 'Z': (108, 531)}
+
+romania = GraphProblem('A', 'B', connections, locations=locations)
+
+
+def draw_romania():
+    """Plot the Romania graph (needs matplotlib; run inside a notebook or
+    with an interactive backend to actually see the figure)."""
+    import pylab
+    pylab.clf()
+    nx.draw(romania.graph, romania.locations, with_labels=True)
+    pylab.show()
+
+
+if __name__ == "__main__":
+    print("Toy successors of C:", toy.successors('C'))
+
+    sol = uniform_cost_search(toy)
+    path = [(node.state, node.action) for node in sol.getPath()]
+    print("Uniform-cost solution S -> G:", path)

cosc604-0.1.0/src/cosc604/priority_queue_demo.py

@@ -0,0 +1,62 @@
+"""Standalone examples of how searches.PriorityQueue orders items.
+
+The PriorityQueue is a Fringe that takes a function `f` at construction time.
+`f` maps an item (later: a search Node) to a priority; the queue always pops
+the item with the lowest priority first. These two examples use plain
+integers and strings (not Nodes) so you can see the ordering mechanics in
+isolation, before PriorityQueue gets reused as the fringe for
+uniform-cost / A* search in searches.py.
+
+Run directly with: python -m cosc604.priority_queue_demo
+"""
+from .searches import PriorityQueue
+
+
+def digitSum(nr):
+    """Priority = sum of the item's digits (smaller sum -> popped first)."""
+    ds = 0
+    while nr > 0:
+        ds += nr % 10
+        nr = nr // 10
+    return ds
+
+
+def countImportance(title):
+    """The importance is the number of V's in the title, with more V's being
+    more important. The negation is used so that the priority queue will
+    order elements with more V's first, since the priority queue orders by
+    lowest value first."""
+    return -title.split()[0].count('V')
+
+
+def demo_digit_sum():
+    print("=== PriorityQueue ordered by digit sum ===")
+    pq = PriorityQueue(digitSum)
+
+    # Example from class: the priority queue will order elements based on
+    # the sum of their digits
+    for element in [432, 52, 99, 12]:
+        pq.push(element)
+
+    while not pq.empty():
+        print(pq.pop())
+        print("Remaining PQ:", pq.fringe)
+
+
+def demo_vip_titles():
+    print("=== PriorityQueue ordered by number of V's in the title ===")
+    pq = PriorityQueue(countImportance)
+    pq.push("Normal dude")
+    pq.push("VVVIP Elon Musk")
+    pq.push("Voldemort")
+    pq.push("VVIP Bill Gates")
+
+    while not pq.empty():
+        print(pq.pop())
+        print("Remaining PQ:", pq.fringe)
+
+
+if __name__ == "__main__":
+    demo_digit_sum()
+    print()
+    demo_vip_titles()

cosc604-0.1.0/src/cosc604/puzzle_problem.py

@@ -0,0 +1,66 @@
+"""The sliding tile puzzle problem (e.g. the 8-puzzle for size=3).
+
+PuzzleState.successors/__hash__/__eq__ are left as stubs for you to
+implement -- see the comments inside each method. Once PuzzleState is
+complete, PuzzleProblem plugs straight into the generic search algorithms
+in searches.py, the same way GraphProblem does.
+"""
+import random
+
+import numpy as np
+
+
+class PuzzleState:
+    def __init__(self, matrix=None, goal=False, init=False, size=3):
+        self.size = size
+        if not matrix is None:  # 0 represents empty spot
+            self.matrix = matrix
+        else:  # defining init or goal state
+            permutation = np.array(range(size * size))
+            if init:
+                random.shuffle(permutation)
+            self.matrix = permutation.reshape((size, size))
+
+    def successors(self):
+        pass
+        # return a list of successors
+        # each successor is a tuple of
+        # 1. a string, describing the action,
+        # 2. action cost (here 1),
+        # 3. and the new state
+
+    def __hash__(self):
+        pass
+        # return a hash code, if you have a matrix, you can uncomment this:
+        # return hash(tuple(self.matrix.flatten()))
+
+    def __eq__(self, other):
+        pass
+        # this function defines equality between objects, if you have a matrix, you can uncomment this:
+        # return np.alltrue(other.matrix == self.matrix)
+
+    def __repr__(self):
+        return str(self.matrix)
+
+
+class PuzzleProblem:
+    def __init__(self, size=3):  # size 3 means 3x3 field
+        self.size = size
+        self.initial = PuzzleState(init=True, size=size)  # init state is shuffled
+        self.goal = PuzzleState(goal=True, size=size)  # goal state is unshuffled
+
+    def successors(self, state):
+        # this assumes that PuzzleState does the actual job of finding the successors
+        return state.successors()
+
+    def goal_test(self, state):
+        return state == self.goal
+
+
+if __name__ == "__main__":
+    puzzle = PuzzleProblem(size=3)
+    print("Initial state:\n", puzzle.initial)
+    print("Goal state:\n", puzzle.goal)
+    # Once PuzzleState is implemented, e.g.:
+    #   from searches import breadth_first_graph_search
+    #   sol = breadth_first_graph_search(puzzle)

cosc604-0.1.0/src/cosc604/searches.py

@@ -0,0 +1,142 @@
+"""Generic search infrastructure: fringes (queues), the Node class, and the
+graph/tree search algorithms, plus convenience wrappers for the standard
+search strategies (BFS, DFS, uniform-cost, A*).
+
+This module is problem-agnostic: it only relies on a `problem` object that
+exposes `initial`, `goal_test(state)` and `successors(state)`. See
+graph_problem.py and puzzle_problem.py for concrete problems.
+"""
+import bisect
+
+
+# ---------------------------------------------------------------------------
+# Fringes (the frontier / open list used by search)
+# ---------------------------------------------------------------------------
+
+class Fringe:
+    def __init__(self):
+        self.fringe = []
+
+    def empty(self):
+        return len(self.fringe) == 0
+
+
+class FIFO(Fringe):
+    """First-in-first-out queue -> breadth-first search."""
+    def push(self, item):
+        self.fringe.append(item)
+
+    def pop(self):
+        return self.fringe.pop(0)
+
+
+class LIFO(Fringe):
+    """Last-in-first-out queue (a stack) -> depth-first search."""
+    def push(self, item):
+        self.fringe.append(item)
+
+    def pop(self):
+        return self.fringe.pop()
+
+
+class PriorityQueue(Fringe):
+    """Orders items by ascending priority, where priority is computed by
+    the function `f` passed at construction time. See priority_queue_demo.py
+    for standalone examples of how `f` shapes the ordering."""
+    def __init__(self, f):
+        self.f = f
+        super().__init__()
+
+    def push(self, item):
+        # apply the function that provides the priority for the current item
+        # later, items will be nodes, and priorities will be backward-, forward cost or both
+        priority = self.f(item)
+        bisect.insort(self.fringe, (priority, item))
+
+    def pop(self):
+        return self.fringe.pop(0)[1]
+
+
+# ---------------------------------------------------------------------------
+# Search tree node
+# ---------------------------------------------------------------------------
+
+class Node:
+    def __init__(self, state=None, parent=None, action=None, path_cost=0):
+        self.state = state
+        self.parent = parent
+        self.action = action
+        self.path_cost = path_cost
+
+    def getPath(self):
+        """getting the path of parents up to the root"""
+        currentNode = self
+        path = [self]
+        while currentNode.parent:  # stops when parent is None, ie root
+            path.append(currentNode.parent)
+            currentNode = currentNode.parent
+        path.reverse()  # from root to this node
+        return path
+
+    def expand(self, problem):
+        successors = problem.successors(self.state)
+        return [Node(newState, self, action, self.path_cost + cost)
+                for (action, cost, newState) in successors]
+
+
+# ---------------------------------------------------------------------------
+# Search algorithms
+# ---------------------------------------------------------------------------
+
+def graph_search(problem, fringe):
+    """Search through the successors of a problem to find a goal.
+    The argument fringe should be an empty queue.
+    If two paths reach a state, only use the best one. [Fig. 3.18]"""
+    closed = set()  # can store hashable objects, thats why we need to define a hash code for states
+    fringe.push(Node(problem.initial))
+    while not fringe.empty():
+        node = fringe.pop()
+        if problem.goal_test(node.state):
+            return node
+        if node.state not in closed:
+            closed.add(node.state)
+            successors = node.expand(problem)
+            for snode in successors:
+                fringe.push(snode)
+
+
+def tree_search(problem, fringe):
+    """Search through the successors of a problem to find a goal.
+    The argument fringe should be an empty queue."""
+    fringe.push(Node(problem.initial))
+    while not fringe.empty():
+        node = fringe.pop()
+        if problem.goal_test(node.state):
+            return node
+        successors = node.expand(problem)
+        for snode in successors:
+            fringe.push(snode)
+
+
+# ---------------------------------------------------------------------------
+# Convenience functions for the standard search strategies
+# ---------------------------------------------------------------------------
+
+def breadth_first_graph_search(problem):
+    return graph_search(problem, FIFO())
+
+
+def depth_first_graph_search(problem):
+    return graph_search(problem, LIFO())
+
+
+def depth_first_tree_search(problem):
+    return tree_search(problem, LIFO())
+
+
+def astar_graph_search(problem, f):
+    return graph_search(problem, PriorityQueue(f))
+
+
+def uniform_cost_search(problem):
+    return graph_search(problem, PriorityQueue(lambda node: node.path_cost))

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

@@ -0,0 +1,93 @@
+Metadata-Version: 2.4
+Name: cosc604
+Version: 0.1.0
+Summary: Teaching implementations of search algorithms (BFS, DFS, UCS, A*) from Russell & Norvig's Artificial Intelligence: A Modern Approach, developed for COSC604.
+Author-email: Andreas Henschel <andreas.henschel@ku.ac.ae>
+License: MIT
+Keywords: artificial-intelligence,search,aima,education,russell-norvig
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Education
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Education
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: networkx
+Provides-Extra: plot
+Requires-Dist: matplotlib; extra == "plot"
+Dynamic: license-file
+
+# cosc604
+
+Teaching code for **COSC604 – Techniques in Artificial Intelligence**,
+developed alongside Assignment 1 (instructor: Andreas Henschel,
+andreas.henschel@ku.ac.ae). It implements the generic search infrastructure
+from Russell & Norvig, *Artificial Intelligence: A Modern Approach* (Ch. 3):
+fringes/queues, the search-tree `Node`, `graph_search`/`tree_search`, and the
+standard strategies built on top of them (BFS, DFS, uniform-cost, A*).
+
+`Assignment1.ipynb` walks through the same code interactively, with the
+routing-problem and tile-puzzle exercises described there. The modules under
+`src/cosc604/` are the packaged, importable version of that code.
+
+## Package layout
+
+| Module | Contents |
+| --- | --- |
+| `cosc604.searches` | `Fringe`, `FIFO`, `LIFO`, `PriorityQueue`, `Node`, `graph_search`, `tree_search`, and the convenience wrappers `breadth_first_graph_search`, `depth_first_graph_search`, `depth_first_tree_search`, `astar_graph_search`, `uniform_cost_search`. |
+| `cosc604.priority_queue_demo` | Standalone examples of how `PriorityQueue`'s priority function `f` shapes ordering (digit-sum, "VIP title" count). Run with `python -m cosc604.priority_queue_demo`. |
+| `cosc604.graph_problem` | `GraphProblem` — the routing problem from the lecture slides, built on `networkx`. Includes the toy example and the Romania map. |
+| `cosc604.puzzle_problem` | `PuzzleProblem` / `PuzzleState` — the sliding tile puzzle (8-puzzle for `size=3`). `PuzzleState.successors`, `__hash__` and `__eq__` are left as an exercise — implement them to make the puzzle searchable. |
+
+## Installation
+
+From PyPI:
+
+```bash
+pip install cosc604
+```
+
+Or, from this directory, as an editable install:
+
+```bash
+pip install -e .
+```
+
+This pulls in `numpy` and `networkx`. To also plot the Romania graph
+(`graph_problem.draw_romania()`), install the optional `plot` extra:
+
+```bash
+pip install "cosc604[plot]"
+```
+
+## Quickstart
+
+```python
+from cosc604 import GraphProblem, uniform_cost_search
+
+connections = [('S', 'A', 5), ('S', 'B', 3), ('S', 'C', 1),
+               ('A', 'G', 1), ('B', 'G', 2), ('C', 'G', 17)]
+toy = GraphProblem('S', 'G', connections, directed=True)
+
+solution = uniform_cost_search(toy)
+print([(node.state, node.action) for node in solution.getPath()])
+```
+
+## Assignment
+
+Assignment 1 asks you to:
+
+1. Add a `LIFO` fringe and complete the generic search algorithms (both done
+   here) — read through `searches.py` to understand how `graph_search` and
+   `tree_search` use a `Fringe` to implement each strategy.
+2. Implement `PuzzleState.successors`, `__hash__` and `__eq__` in
+   `puzzle_problem.py` so `PuzzleProblem` can be solved with the same search
+   algorithms used for the routing problem, and reproduce the tile-puzzle
+   results shown in the slides (`tileslides.png`).
+
+## License
+
+MIT — see [LICENSE](LICENSE).

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

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+src/cosc604/__init__.py
+src/cosc604/graph_problem.py
+src/cosc604/priority_queue_demo.py
+src/cosc604/puzzle_problem.py
+src/cosc604/searches.py
+src/cosc604.egg-info/PKG-INFO
+src/cosc604.egg-info/SOURCES.txt
+src/cosc604.egg-info/dependency_links.txt
+src/cosc604.egg-info/requires.txt
+src/cosc604.egg-info/top_level.txt

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

@@ -0,0 +1 @@
+

cosc604-0.1.0/src/cosc604.egg-info/requires.txt

@@ -0,0 +1,5 @@
+numpy
+networkx
+
+[plot]
+matplotlib

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

@@ -0,0 +1 @@
+cosc604