job-shop-lib 0.2.0__tar.gz → 0.3.0__tar.gz

{job_shop_lib-0.2.0 → job_shop_lib-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: job-shop-lib
-Version: 0.2.0
+Version: 0.3.0
 Summary: An easy-to-use and modular Python library for the Job Shop Scheduling Problem (JSSP)
 License: MIT
 Author: Pabloo22

{job_shop_lib-0.2.0 → job_shop_lib-0.3.0}/job_shop_lib/__init__.py

@@ -1,12 +1,13 @@
 """Contains the main data structures and base classes.
 """
 
+from job_shop_lib.exceptions import JobShopLibError, NoSolutionFoundError
 from job_shop_lib.operation import Operation
 from job_shop_lib.job_shop_instance import JobShopInstance
 from job_shop_lib.scheduled_operation import ScheduledOperation
 from job_shop_lib.schedule import Schedule
 from job_shop_lib.base_solver import BaseSolver, Solver
-from job_shop_lib.exceptions import JobShopLibError, NoSolutionFoundError
+
 
 __all__ = [
     "Operation",

{job_shop_lib-0.2.0 → job_shop_lib-0.3.0}/job_shop_lib/dispatching/__init__.py

@@ -1,7 +1,8 @@
 """Package containing all the functionality to solve the Job Shop Scheduling
 Problem step-by-step."""
 
-from job_shop_lib.dispatching.dispatcher import Dispatcher
+from job_shop_lib.dispatching.dispatcher import Dispatcher, DispatcherObserver
+from job_shop_lib.dispatching.history_tracker import HistoryTracker
 from job_shop_lib.dispatching.dispatching_rules import (
     shortest_processing_time_rule,
     first_come_first_served_rule,
@@ -46,4 +47,6 @@ __all__ = [
     "PruningFunction",
     "pruning_function_factory",
     "composite_pruning_function_factory",
+    "DispatcherObserver",
+    "HistoryTracker",
 ]

{job_shop_lib-0.2.0 → job_shop_lib-0.3.0}/job_shop_lib/dispatching/dispatcher.py

@@ -2,8 +2,11 @@
 
 from __future__ import annotations
 
+import abc
+from typing import Any
 from collections.abc import Callable
 from collections import deque
+from functools import wraps
 
 from job_shop_lib import (
     JobShopInstance,
@@ -13,6 +16,59 @@ from job_shop_lib import (
 )
 
 
+# Added here to avoid circular imports
+class DispatcherObserver(abc.ABC):
+    """Interface for classes that observe the dispatcher."""
+
+    def __init__(self, dispatcher: Dispatcher):
+        """Initializes the observer with the dispatcher and subscribes to
+        it."""
+        self.dispatcher = dispatcher
+        self.dispatcher.subscribe(self)
+
+    @abc.abstractmethod
+    def update(self, scheduled_operation: ScheduledOperation):
+        """Called when an operation is scheduled on a machine."""
+
+    @abc.abstractmethod
+    def reset(self):
+        """Called when the dispatcher is reset."""
+
+    def __str__(self) -> str:
+        return self.__class__.__name__
+
+    def __repr__(self) -> str:
+        return str(self)
+
+
+def _dispatcher_cache(method):
+    """Decorator to cache results of a method based on its name.
+
+    This decorator assumes that the class has an attribute called `_cache`
+    that is a dictionary. It caches the result of the method based on its
+    name. If the result is already cached, it returns the cached result
+    instead of recomputing it.
+
+    The decorator is useful since the dispatcher class can clear the cache
+    when the state of the dispatcher changes.
+    """
+
+    @wraps(method)
+    def wrapper(self: Dispatcher, *args, **kwargs):
+        # pylint: disable=protected-access
+        cache_key = method.__name__
+        cached_result = self._cache.get(cache_key)
+        if cached_result is not None:
+            return cached_result
+
+        result = method(self, *args, **kwargs)
+        self._cache[cache_key] = result
+        return result
+
+    return wrapper
+
+
+# pylint: disable=too-many-instance-attributes
 class Dispatcher:
     """Handles the logic of scheduling operations on machines.
 
@@ -27,8 +83,10 @@ class Dispatcher:
         schedule:
             The schedule of operations on machines.
         pruning_function:
-            The pipeline of pruning methods to be used to filter out
-            operations from the list of available operations.
+            A function that filters out operations that are not ready to be
+            scheduled.
+        subscribers:
+            A list of observers that are subscribed to the dispatcher.
     """
 
     __slots__ = (
@@ -38,6 +96,8 @@ class Dispatcher:
         "_job_next_operation_index",
         "_job_next_available_time",
         "pruning_function",
+        "subscribers",
+        "_cache",
     )
 
     def __init__(
@@ -52,20 +112,28 @@ class Dispatcher:
         Args:
             instance:
                 The instance of the job shop problem to be solved.
-            pruning_strategies:
-                A list of pruning strategies to be used to filter out
-                operations from the list of available operations. Supported
-                values are 'dominated_operations' and 'non_immediate_machines'.
-                Defaults to [PruningStrategy.DOMINATED_OPERATIONS]. To disable
-                pruning, pass an empty list.
+            pruning_function:
+                A function that filters out operations that are not ready to
+                be scheduled. The function should take the dispatcher and a
+                list of operations as input and return a list of operations
+                that are ready to be scheduled. If `None`, no pruning is done.
         """
 
         self.instance = instance
         self.schedule = Schedule(self.instance)
+        self.pruning_function = pruning_function
+
         self._machine_next_available_time = [0] * self.instance.num_machines
         self._job_next_operation_index = [0] * self.instance.num_jobs
         self._job_next_available_time = [0] * self.instance.num_jobs
-        self.pruning_function = pruning_function
+        self.subscribers: list[DispatcherObserver] = []
+        self._cache: dict[str, Any] = {}
+
+    def __str__(self) -> str:
+        return f"{self.__class__.__name__}({self.instance})"
+
+    def __repr__(self) -> str:
+        return str(self)
 
     @property
     def machine_next_available_time(self) -> list[int]:
@@ -117,12 +185,23 @@ class Dispatcher:
                     operations.popleft()
         return dispatcher.schedule
 
+    def subscribe(self, observer: DispatcherObserver):
+        """Subscribes an observer to the dispatcher."""
+        self.subscribers.append(observer)
+
+    def unsubscribe(self, observer: DispatcherObserver):
+        """Unsubscribes an observer from the dispatcher."""
+        self.subscribers.remove(observer)
+
     def reset(self) -> None:
         """Resets the dispatcher to its initial state."""
         self.schedule.reset()
         self._machine_next_available_time = [0] * self.instance.num_machines
         self._job_next_operation_index = [0] * self.instance.num_jobs
         self._job_next_available_time = [0] * self.instance.num_jobs
+        self._cache = {}
+        for subscriber in self.subscribers:
+            subscriber.reset()
 
     def dispatch(self, operation: Operation, machine_id: int) -> None:
         """Schedules the given operation on the given machine.
@@ -153,6 +232,10 @@ class Dispatcher:
         self.schedule.add(scheduled_operation)
         self._update_tracking_attributes(scheduled_operation)
 
+        # Notify subscribers
+        for subscriber in self.subscribers:
+            subscriber.update(scheduled_operation)
+
     def is_operation_ready(self, operation: Operation) -> bool:
         """Returns True if the given operation is ready to be scheduled.
 
@@ -164,11 +247,15 @@ class Dispatcher:
                 The operation to be checked.
         """
         return (
-            self.job_next_operation_index[operation.job_id]
+            self._job_next_operation_index[operation.job_id]
             == operation.position_in_job
         )
 
-    def start_time(self, operation: Operation, machine_id: int) -> int:
+    def start_time(
+        self,
+        operation: Operation,
+        machine_id: int,
+    ) -> int:
         """Computes the start time for the given operation on the given
         machine.
 
@@ -181,11 +268,12 @@ class Dispatcher:
                 The operation to be scheduled.
             machine_id:
                 The id of the machine on which the operation is to be
-                scheduled.
+                scheduled. If None, the start time is computed based on the
+                next available time for the operation on any machine.
         """
         return max(
-            self.machine_next_available_time[machine_id],
-            self.job_next_available_time[operation.job_id],
+            self._machine_next_available_time[machine_id],
+            self._job_next_available_time[operation.job_id],
         )
 
     def _update_tracking_attributes(
@@ -196,10 +284,12 @@ class Dispatcher:
         machine_id = scheduled_operation.machine_id
         end_time = scheduled_operation.end_time
 
-        self.machine_next_available_time[machine_id] = end_time
-        self.job_next_operation_index[job_id] += 1
-        self.job_next_available_time[job_id] = end_time
+        self._machine_next_available_time[machine_id] = end_time
+        self._job_next_operation_index[job_id] += 1
+        self._job_next_available_time[job_id] = end_time
+        self._cache = {}
 
+    @_dispatcher_cache
     def current_time(self) -> int:
         """Returns the current time of the schedule.
 
@@ -207,7 +297,8 @@ class Dispatcher:
         operations.
         """
         available_operations = self.available_operations()
-        return self.min_start_time(available_operations)
+        current_time = self.min_start_time(available_operations)
+        return current_time
 
     def min_start_time(self, operations: list[Operation]) -> int:
         """Returns the minimum start time of the available operations."""
@@ -220,6 +311,7 @@ class Dispatcher:
                 min_start_time = min(min_start_time, start_time)
         return int(min_start_time)
 
+    @_dispatcher_cache
     def uncompleted_operations(self) -> list[Operation]:
         """Returns the list of operations that have not been scheduled.
 
@@ -228,30 +320,24 @@ class Dispatcher:
         It is more efficient than checking all operations in the instance.
         """
         uncompleted_operations = []
-        for job_id, next_position in enumerate(self.job_next_operation_index):
+        for job_id, next_position in enumerate(self._job_next_operation_index):
             operations = self.instance.jobs[job_id][next_position:]
             uncompleted_operations.extend(operations)
         return uncompleted_operations
 
+    @_dispatcher_cache
     def available_operations(self) -> list[Operation]:
         """Returns a list of available operations for processing, optionally
-        filtering out operations known to be bad choices.
+        filtering out operations using the pruning function.
 
         This method first gathers all possible next operations from the jobs
-        being processed. It then optionally filters these operations to exclude
-        ones that are deemed inefficient or suboptimal choices.
-
-        An operation is sub-optimal if there is another operation that could
-        be scheduled in the same machine that would finish before the start
-        time of the sub-optimal operation.
+        being processed. It then optionally filters these operations using the
+        pruning function.
 
         Returns:
             A list of Operation objects that are available for scheduling.
-
-        Raises:
-            ValueError: If using the filter_bad_choices option and one of the
-                available operations can be scheduled in more than one machine.
         """
+
         available_operations = self._available_operations()
         if self.pruning_function is not None:
             available_operations = self.pruning_function(
@@ -261,7 +347,7 @@ class Dispatcher:
 
     def _available_operations(self) -> list[Operation]:
         available_operations = []
-        for job_id, next_position in enumerate(self.job_next_operation_index):
+        for job_id, next_position in enumerate(self._job_next_operation_index):
             if next_position == len(self.instance.jobs[job_id]):
                 continue
             operation = self.instance.jobs[job_id][next_position]

{job_shop_lib-0.2.0 → job_shop_lib-0.3.0}/job_shop_lib/dispatching/dispatching_rule_solver.py

@@ -76,12 +76,15 @@ class DispatchingRuleSolver(BaseSolver):
         self.machine_chooser = machine_chooser
         self.pruning_function = pruning_function
 
-    def solve(self, instance: JobShopInstance) -> Schedule:
+    def solve(
+        self, instance: JobShopInstance, dispatcher: Dispatcher | None = None
+    ) -> Schedule:
         """Returns a schedule for the given job shop instance using the
         dispatching rule algorithm."""
-        dispatcher = Dispatcher(
-            instance, pruning_function=self.pruning_function
-        )
+        if dispatcher is None:
+            dispatcher = Dispatcher(
+                instance, pruning_function=self.pruning_function
+            )
         while not dispatcher.schedule.is_complete():
             self.step(dispatcher)
 
@@ -101,11 +104,16 @@ class DispatchingRuleSolver(BaseSolver):
 
 
 if __name__ == "__main__":
-    import cProfile
+    import time
     from job_shop_lib.benchmarking import load_benchmark_instance
 
     ta_instances = []
     for i in range(1, 81):
         ta_instances.append(load_benchmark_instance(f"ta{i:02d}"))
     solver = DispatchingRuleSolver(dispatching_rule="most_work_remaining")
-    cProfile.run("for instance in ta_instances: solver.solve(instance)")
+    # cProfile.run("for instance in ta_instances: solver.solve(instance)")
+    start = time.perf_counter()
+    for instance_ in ta_instances:
+        solver.solve(instance_)
+    end = time.perf_counter()
+    print(f"Elapsed time: {end - start:.2f} seconds.")

job_shop_lib-0.3.0/job_shop_lib/dispatching/history_tracker.py

@@ -0,0 +1,20 @@
+"""Home of the `HistoryTracker` class."""
+
+from job_shop_lib.dispatching import DispatcherObserver, Dispatcher
+from job_shop_lib import ScheduledOperation
+
+
+class HistoryTracker(DispatcherObserver):
+    """Observer that stores the history of the dispatcher."""
+
+    def __init__(self, dispatcher: Dispatcher):
+        """Initializes the observer with the current state of the
+        dispatcher."""
+        super().__init__(dispatcher)
+        self.history: list[ScheduledOperation] = []
+
+    def update(self, scheduled_operation: ScheduledOperation):
+        self.history.append(scheduled_operation)
+
+    def reset(self):
+        self.history = []

{job_shop_lib-0.2.0 → job_shop_lib-0.3.0}/job_shop_lib/graphs/job_shop_graph.py

@@ -3,13 +3,14 @@
 import collections
 import networkx as nx
 
-from job_shop_lib import JobShopInstance, Operation
+from job_shop_lib import JobShopInstance, JobShopLibError
 from job_shop_lib.graphs import Node, NodeType
 
 
 NODE_ATTR = "node"
 
 
+# pylint: disable=too-many-instance-attributes
 class JobShopGraph:
     """Data structure to represent a `JobShopInstance` as a graph.
 
@@ -30,30 +31,8 @@ class JobShopGraph:
             The directed graph representing the job shop, where nodes are
                 operations, machines, jobs, or abstract concepts like global,
                 source, and sink, with edges indicating dependencies.
-        nodes:
-            A list of all nodes, encapsulated by the `Node` class, in the
-                graph.
-        nodes_by_type:
-            A dictionary categorizing nodes by their `NodeType`,
-                facilitating access to nodes of a particular type.
-        nodes_by_machine:
-            A nested list mapping each machine to its associated
-                operation nodes, aiding in machine-specific analysis.
-        nodes_by_job:
-            Similar to `nodes_by_machine`, but maps jobs to their
-                operation nodes, useful for job-specific traversal.
     """
 
-    __slots__ = (
-        "instance",
-        "graph",
-        "nodes",
-        "nodes_by_type",
-        "nodes_by_machine",
-        "nodes_by_job",
-        "_next_node_id",
-    )
-
     def __init__(self, instance: JobShopInstance):
         """Initializes the graph with the given instance.
 
@@ -67,24 +46,62 @@ class JobShopGraph:
         self.graph = nx.DiGraph()
         self.instance = instance
 
-        self.nodes: list[Node] = []
-
-        self.nodes_by_type: dict[NodeType, list[Node]] = (
+        self._nodes: list[Node] = []
+        self._nodes_by_type: dict[NodeType, list[Node]] = (
             collections.defaultdict(list)
         )
-
-        self.nodes_by_machine: list[list[Node]] = [
+        self._nodes_by_machine: list[list[Node]] = [
             [] for _ in range(instance.num_machines)
         ]
-
-        self.nodes_by_job: list[list[Node]] = [
+        self._nodes_by_job: list[list[Node]] = [
             [] for _ in range(instance.num_jobs)
         ]
-
         self._next_node_id = 0
-
+        self.removed_nodes: list[bool] = []
         self._add_operation_nodes()
 
+    @property
+    def nodes(self) -> list[Node]:
+        """List of all nodes added to the graph.
+
+        It may contain nodes that have been removed from the graph.
+        """
+        return self._nodes
+
+    @property
+    def nodes_by_type(self) -> dict[NodeType, list[Node]]:
+        """Dictionary mapping node types to lists of nodes.
+
+        It may contain nodes that have been removed from the graph.
+        """
+        return self._nodes_by_type
+
+    @property
+    def nodes_by_machine(self) -> list[list[Node]]:
+        """List of lists mapping machine ids to operation nodes.
+
+        It may contain nodes that have been removed from the graph.
+        """
+        return self._nodes_by_machine
+
+    @property
+    def nodes_by_job(self) -> list[list[Node]]:
+        """List of lists mapping job ids to operation nodes.
+
+        It may contain nodes that have been removed from the graph.
+        """
+        return self._nodes_by_job
+
+    @property
+    def num_edges(self) -> int:
+        """Number of edges in the graph."""
+        return self.graph.number_of_edges()
+
+    @property
+    def num_job_nodes(self) -> int:
+        """Number of job nodes in the graph."""
+        return len(self._nodes_by_type[NodeType.JOB])
+
     def _add_operation_nodes(self) -> None:
         """Adds operation nodes to the graph."""
         for job in self.instance.jobs:
@@ -92,10 +109,6 @@ class JobShopGraph:
                 node = Node(node_type=NodeType.OPERATION, operation=operation)
                 self.add_node(node)
 
-    def get_operation_from_id(self, operation_id: int) -> Operation:
-        """Returns the operation with the given id."""
-        return self.nodes[operation_id].operation
-
     def add_node(self, node_for_adding: Node) -> None:
         """Adds a node to the graph and updates relevant class attributes.
 
@@ -121,15 +134,16 @@ class JobShopGraph:
         self.graph.add_node(
             node_for_adding.node_id, **{NODE_ATTR: node_for_adding}
         )
-        self.nodes_by_type[node_for_adding.node_type].append(node_for_adding)
-        self.nodes.append(node_for_adding)
+        self._nodes_by_type[node_for_adding.node_type].append(node_for_adding)
+        self._nodes.append(node_for_adding)
         self._next_node_id += 1
+        self.removed_nodes.append(False)
 
         if node_for_adding.node_type == NodeType.OPERATION:
             operation = node_for_adding.operation
-            self.nodes_by_job[operation.job_id].append(node_for_adding)
+            self._nodes_by_job[operation.job_id].append(node_for_adding)
             for machine_id in operation.machines:
-                self.nodes_by_machine[machine_id].append(node_for_adding)
+                self._nodes_by_machine[machine_id].append(node_for_adding)
 
     def add_edge(
         self, u_of_edge: Node | int, v_of_edge: Node | int, **attr
@@ -146,14 +160,43 @@ class JobShopGraph:
             **attr: Additional attributes to be added to the edge.
 
         Raises:
-            ValueError: If `u_of_edge` or `v_of_edge` are not in the graph.
+            JobShopLibError: If `u_of_edge` or `v_of_edge` are not in the
+                graph.
         """
         if isinstance(u_of_edge, Node):
             u_of_edge = u_of_edge.node_id
         if isinstance(v_of_edge, Node):
             v_of_edge = v_of_edge.node_id
         if u_of_edge not in self.graph or v_of_edge not in self.graph:
-            raise ValueError(
+            raise JobShopLibError(
                 "`u_of_edge` and `v_of_edge` must be in the graph."
             )
         self.graph.add_edge(u_of_edge, v_of_edge, **attr)
+
+    def remove_node(self, node_id: int) -> None:
+        """Removes a node from the graph and the isolated nodes that result
+        from the removal.
+
+        Args:
+            node_id: The id of the node to remove.
+        """
+        self.graph.remove_node(node_id)
+        self.removed_nodes[node_id] = True
+
+        isolated_nodes = list(nx.isolates(self.graph))
+        for isolated_node in isolated_nodes:
+            self.removed_nodes[isolated_node] = True
+
+        self.graph.remove_nodes_from(isolated_nodes)
+
+    def is_removed(self, node: int | Node) -> bool:
+        """Returns whether the node is removed from the graph.
+
+        Args:
+            node: The node to check. If it is a `Node`, its `node_id` is used
+                as the node to check. Otherwise, it is assumed to be the
+                `node_id` of the node to check.
+        """
+        if isinstance(node, Node):
+            node = node.node_id
+        return self.removed_nodes[node]

{job_shop_lib-0.2.0 → job_shop_lib-0.3.0}/job_shop_lib/graphs/node.py

@@ -1,6 +1,6 @@
 """Home of the `Node` class."""
 
-from job_shop_lib import Operation
+from job_shop_lib import Operation, JobShopLibError
 from job_shop_lib.graphs.constants import NodeType
 
 
@@ -35,7 +35,7 @@ class Node:
     print(graph[1])  # "some value"
     ```
 
-    Args:
+    Attributes:
         node_type:
             The type of the node. It can be one of the following:
             - NodeType.OPERATION
@@ -43,15 +43,6 @@ class Node:
             - NodeType.JOB
             - NodeType.GLOBAL
             ...
-        operation:
-            The operation of the node. It should be provided if the node_type
-            is NodeType.OPERATION.
-        machine_id:
-            The id of the machine of the node. It should be provided if the
-            node_type is NodeType.MACHINE.
-        job_id:
-            The id of the job of the node. It should be provided if the
-            node_type is NodeType.JOB.
     """
 
     __slots__ = "node_type", "_node_id", "_operation", "_machine_id", "_job_id"
@@ -63,14 +54,42 @@ class Node:
         machine_id: int | None = None,
         job_id: int | None = None,
     ):
+        """Initializes the node with the given attributes.
+
+        Args:
+            node_type:
+                The type of the node. It can be one of the following:
+                - NodeType.OPERATION
+                - NodeType.MACHINE
+                - NodeType.JOB
+                - NodeType.GLOBAL
+                ...
+            operation:
+                The operation of the node. It should be provided if the
+                `node_type` is NodeType.OPERATION.
+            machine_id:
+                The id of the machine of the node. It should be provided if the
+                node_type is NodeType.MACHINE.
+            job_id:
+                The id of the job of the node. It should be provided if the
+                node_type is NodeType.JOB.
+
+        Raises:
+            JobShopLibError:
+                If the node_type is OPERATION and operation is None.
+            JobShopLibError:
+                If the node_type is MACHINE and machine_id is None.
+            JobShopLibError:
+                If the node_type is JOB and job_id is None.
+        """
         if node_type == NodeType.OPERATION and operation is None:
-            raise ValueError("Operation node must have an operation.")
+            raise JobShopLibError("Operation node must have an operation.")
 
         if node_type == NodeType.MACHINE and machine_id is None:
-            raise ValueError("Machine node must have a machine_id.")
+            raise JobShopLibError("Machine node must have a machine_id.")
 
         if node_type == NodeType.JOB and job_id is None:
-            raise ValueError("Job node must have a job_id.")
+            raise JobShopLibError("Job node must have a job_id.")
 
         self.node_type = node_type
         self._node_id: int | None = None
@@ -83,7 +102,7 @@ class Node:
     def node_id(self) -> int:
         """Returns a unique identifier for the node."""
         if self._node_id is None:
-            raise ValueError("Node has not been assigned an id.")
+            raise JobShopLibError("Node has not been assigned an id.")
         return self._node_id
 
     @node_id.setter
@@ -97,7 +116,7 @@ class Node:
         This property is mandatory for nodes of type `OPERATION`.
         """
         if self._operation is None:
-            raise ValueError("Node has no operation.")
+            raise JobShopLibError("Node has no operation.")
         return self._operation
 
     @property
@@ -107,7 +126,7 @@ class Node:
         This property is mandatory for nodes of type `MACHINE`.
         """
         if self._machine_id is None:
-            raise ValueError("Node has no `machine_id`.")
+            raise JobShopLibError("Node has no `machine_id`.")
         return self._machine_id
 
     @property
@@ -117,7 +136,7 @@ class Node:
         This property is mandatory for nodes of type `JOB`.
         """
         if self._job_id is None:
-            raise ValueError("Node has no `job_id`.")
+            raise JobShopLibError("Node has no `job_id`.")
         return self._job_id
 
     def __hash__(self) -> int:

{job_shop_lib-0.2.0 → job_shop_lib-0.3.0}/job_shop_lib/operation.py

@@ -2,6 +2,8 @@
 
 from __future__ import annotations
 
+from job_shop_lib import JobShopLibError
+
 
 class Operation:
     """Stores machine and duration information for a job operation.
@@ -51,14 +53,14 @@ class Operation:
             ValueError: If the operation has multiple machines in its list.
         """
         if len(self.machines) > 1:
-            raise ValueError("Operation has multiple machines.")
+            raise JobShopLibError("Operation has multiple machines.")
         return self.machines[0]
 
     @property
     def job_id(self) -> int:
         """Returns the id of the job that the operation belongs to."""
         if self._job_id is None:
-            raise ValueError("Operation has no job_id.")
+            raise JobShopLibError("Operation has no job_id.")
         return self._job_id
 
     @job_id.setter
@@ -74,7 +76,7 @@ class Operation:
             ValueError: If the operation has no position_in_job.
         """
         if self._position_in_job is None:
-            raise ValueError("Operation has no position_in_job.")
+            raise JobShopLibError("Operation has no position_in_job.")
         return self._position_in_job
 
     @position_in_job.setter
@@ -95,7 +97,7 @@ class Operation:
             ValueError: If the operation has no id.
         """
         if self._operation_id is None:
-            raise ValueError("Operation has no id.")
+            raise JobShopLibError("Operation has no id.")
         return self._operation_id
 
     @operation_id.setter

{job_shop_lib-0.2.0 → job_shop_lib-0.3.0}/job_shop_lib/visualization/create_gif.py

@@ -4,14 +4,18 @@ dispatching rule solver."""
 import os
 import pathlib
 import shutil
-from typing import Callable
+from collections.abc import Callable
 
 import imageio
 import matplotlib.pyplot as plt
 from matplotlib.figure import Figure
 
 from job_shop_lib import JobShopInstance, Schedule, Operation
-from job_shop_lib.dispatching import DispatchingRuleSolver, Dispatcher
+from job_shop_lib.dispatching import (
+    DispatchingRuleSolver,
+    Dispatcher,
+    HistoryTracker,
+)
 from job_shop_lib.visualization.gantt_chart import plot_gantt_chart
 
 
@@ -114,7 +118,11 @@ def plot_gantt_chart_wrapper(
             ha="right",
             va="bottom",
             transform=ax.transAxes,
-            bbox=dict(facecolor="white", alpha=0.5, boxstyle="round,pad=0.5"),
+            bbox={
+                "facecolor": "white",
+                "alpha": 0.5,
+                "boxstyle": "round,pad=0.5",
+            },
         )
         return fig
 
@@ -144,22 +152,23 @@ def create_gantt_chart_frames(
         plot_current_time:
             Whether to plot a vertical line at the current time."""
     dispatcher = Dispatcher(instance, pruning_function=solver.pruning_function)
-    schedule = dispatcher.schedule
-    makespan = solver(instance).makespan()
-    iteration = 0
-
-    while not schedule.is_complete():
-        solver.step(dispatcher)
-        iteration += 1
+    history_tracker = HistoryTracker(dispatcher)
+    makespan = solver.solve(instance, dispatcher).makespan()
+    dispatcher.unsubscribe(history_tracker)
+    dispatcher.reset()
+    for i, scheduled_operation in enumerate(history_tracker.history, start=1):
+        dispatcher.dispatch(
+            scheduled_operation.operation, scheduled_operation.machine_id
+        )
         fig = plot_function(
-            schedule,
+            dispatcher.schedule,
             makespan,
             dispatcher.available_operations(),
         )
         current_time = (
             None if not plot_current_time else dispatcher.current_time()
         )
-        _save_frame(fig, frames_dir, iteration, current_time)
+        _save_frame(fig, frames_dir, i, current_time)
 
 
 def _save_frame(

{job_shop_lib-0.2.0 → job_shop_lib-0.3.0}/job_shop_lib/visualization/disjunctive_graph.py

@@ -8,6 +8,7 @@ import copy
 import matplotlib
 import matplotlib.pyplot as plt
 import networkx as nx
+from networkx.drawing.nx_agraph import graphviz_layout
 
 from job_shop_lib import JobShopInstance
 from job_shop_lib.graphs import (
@@ -65,20 +66,9 @@ def plot_disjunctive_graph(
     # Set up the layout
     # -----------------
     if layout is None:
-        try:
-            from networkx.drawing.nx_agraph import (
-                graphviz_layout,
-            )
-
-            layout = functools.partial(
-                graphviz_layout, prog="dot", args="-Grankdir=LR"
-            )
-        except ImportError:
-            warnings.warn(
-                "Could not import graphviz_layout. "
-                + "Using spring_layout instead."
-            )
-            layout = nx.spring_layout
+        layout = functools.partial(
+            graphviz_layout, prog="dot", args="-Grankdir=LR"
+        )
 
     temp_graph = copy.deepcopy(job_shop_graph.graph)
     # Remove disjunctive edges to get a better layout
@@ -89,11 +79,23 @@ def plot_disjunctive_graph(
             if d["type"] == EdgeType.DISJUNCTIVE
         ]
     )
-    pos = layout(temp_graph)  # type: ignore
+
+    try:
+        pos = layout(temp_graph)
+    except ImportError:
+        warnings.warn(
+            "Default layout requires pygraphviz http://pygraphviz.github.io/. "
+            "Using spring layout instead.",
+        )
+        pos = nx.spring_layout(temp_graph)
 
     # Draw nodes
     # ----------
-    node_colors = [_get_node_color(node) for node in job_shop_graph.nodes]
+    node_colors = [
+        _get_node_color(node)
+        for node in job_shop_graph.nodes
+        if not job_shop_graph.is_removed(node.node_id)
+    ]
 
     nx.draw_networkx_nodes(
         job_shop_graph.graph,
@@ -147,6 +149,8 @@ def plot_disjunctive_graph(
     sink_node = job_shop_graph.nodes_by_type[NodeType.SINK][0]
     labels[sink_node] = "T"
     for operation_node in operation_nodes:
+        if job_shop_graph.is_removed(operation_node.node_id):
+            continue
         labels[operation_node] = (
             f"m={operation_node.operation.machine_id}\n"
             f"d={operation_node.operation.duration}"

{job_shop_lib-0.2.0 → job_shop_lib-0.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "job-shop-lib"
-version = "0.2.0"
+version = "0.3.0"
 description = "An easy-to-use and modular Python library for the Job Shop Scheduling Problem (JSSP)"
 authors = ["Pabloo22 <pablete.arino@gmail.com>"]
 license = "MIT"