job-shop-lib 1.0.0b5__tar.gz → 1.0.1__tar.gz

{job_shop_lib-1.0.0b5 → job_shop_lib-1.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: job-shop-lib
-Version: 1.0.0b5
+Version: 1.0.1
 Summary: An easy-to-use and modular Python library for the Job Shop Scheduling Problem (JSSP)
 License: MIT
 Author: Pabloo22
@@ -12,7 +12,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Provides-Extra: pygraphviz
-Requires-Dist: gymnasium (>=0.29.1,<0.30.0)
+Requires-Dist: gymnasium (>=1.0.0,<2.0.0)
 Requires-Dist: imageio[ffmpeg] (>=2.34.1,<3.0.0)
 Requires-Dist: matplotlib (>=3,<4)
 Requires-Dist: networkx (>=3,<4)
@@ -48,7 +48,7 @@ See the [documentation](https://job-shop-lib.readthedocs.io/en/latest/) for more
 
 JobShopLib is distributed on [PyPI](https://pypi.org/project/job-shop-lib/) and it supports Python 3.10+.
 
-You can install the latest stable version (version 0.5.1) using `pip`:
+You can install the latest stable version using `pip`:
 
 ```bash
 pip install job-shop-lib
@@ -57,13 +57,7 @@ pip install job-shop-lib
 See [this](https://colab.research.google.com/drive/1XV_Rvq1F2ns6DFG8uNj66q_rcowwTZ4H?usp=sharing) Google Colab notebook for a quick start guide! 
 
 
-Version 1.0.0 is currently in beta stage and can be installed with:
-
-```bash
-pip install job-shop-lib==1.0.0b5
-```
-
-Although this version is not stable and may contain breaking changes in subsequent releases, it is recommended to install it to access the new reinforcement learning environments and familiarize yourself with new changes (see the [latest pull requests](https://github.com/Pabloo22/job_shop_lib/pulls?q=is%3Apr+is%3Aclosed)). There is a [documentation page](https://job-shop-lib.readthedocs.io/en/latest/) for versions 1.0.0a3 and onward.
+There is a [documentation page](https://job-shop-lib.readthedocs.io/en/latest/) for versions 1.0.0a3 and onward. See see the [latest pull requests](https://github.com/Pabloo22/job_shop_lib/pulls?q=is%3Apr+is%3Aclosed) for the latest changes.
 
 <!-- end installation -->
 

{job_shop_lib-1.0.0b5 → job_shop_lib-1.0.1}/README.md

@@ -24,7 +24,7 @@ See the [documentation](https://job-shop-lib.readthedocs.io/en/latest/) for more
 
 JobShopLib is distributed on [PyPI](https://pypi.org/project/job-shop-lib/) and it supports Python 3.10+.
 
-You can install the latest stable version (version 0.5.1) using `pip`:
+You can install the latest stable version using `pip`:
 
 ```bash
 pip install job-shop-lib
@@ -33,13 +33,7 @@ pip install job-shop-lib
 See [this](https://colab.research.google.com/drive/1XV_Rvq1F2ns6DFG8uNj66q_rcowwTZ4H?usp=sharing) Google Colab notebook for a quick start guide! 
 
 
-Version 1.0.0 is currently in beta stage and can be installed with:
-
-```bash
-pip install job-shop-lib==1.0.0b5
-```
-
-Although this version is not stable and may contain breaking changes in subsequent releases, it is recommended to install it to access the new reinforcement learning environments and familiarize yourself with new changes (see the [latest pull requests](https://github.com/Pabloo22/job_shop_lib/pulls?q=is%3Apr+is%3Aclosed)). There is a [documentation page](https://job-shop-lib.readthedocs.io/en/latest/) for versions 1.0.0a3 and onward.
+There is a [documentation page](https://job-shop-lib.readthedocs.io/en/latest/) for versions 1.0.0a3 and onward. See see the [latest pull requests](https://github.com/Pabloo22/job_shop_lib/pulls?q=is%3Apr+is%3Aclosed) for the latest changes.
 
 <!-- end installation -->
 

{job_shop_lib-1.0.0b5 → job_shop_lib-1.0.1}/job_shop_lib/__init__.py

@@ -19,7 +19,7 @@ from job_shop_lib._schedule import Schedule
 from job_shop_lib._base_solver import BaseSolver, Solver
 
 
-__version__ = "1.0.0-b.5"
+__version__ = "1.0.1"
 
 __all__ = [
     "Operation",

{job_shop_lib-1.0.0b5 → job_shop_lib-1.0.1}/job_shop_lib/_operation.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from typing import Union, List
 
-from job_shop_lib.exceptions import UninitializedAttributeError
+from job_shop_lib.exceptions import ValidationError
 
 
 class Operation:
@@ -81,8 +81,14 @@ class Operation:
                 If the operation has multiple machines in its list.
         """
         if len(self.machines) > 1:
-            raise UninitializedAttributeError(
-                "Operation has multiple machines."
+            raise ValidationError(
+                "Operation has multiple machines. The `machine_id` property "
+                "should only be used when working with a classic JSSP "
+                "instance. This error prevents silent bugs. To handle "
+                "operations with more machines you have to use the machines "
+                "attribute. If you get this error using `job_shop_lib` "
+                "objects, it means that that object does not support "
+                "operations with multiple machines yet."
             )
         return self.machines[0]
 

{job_shop_lib-1.0.0b5 → job_shop_lib-1.0.1}/job_shop_lib/_scheduled_operation.py

@@ -80,3 +80,6 @@ class ScheduledOperation:
             and self.start_time == value.start_time
             and self.machine_id == value.machine_id
         )
+
+    def __hash__(self) -> int:
+        return hash((self.operation, self.start_time, self.machine_id))

{job_shop_lib-1.0.0b5 → job_shop_lib-1.0.1}/job_shop_lib/dispatching/_dispatcher.py

@@ -336,8 +336,7 @@ class Dispatcher:
                 The operation to be scheduled.
             machine_id:
                 The id of the machine on which the operation is to be
-                scheduled. If ``None``, the start time is computed based on the
-                next available time for the operation on any machine.
+                scheduled.
         """
         return max(
             self._machine_next_available_time[machine_id],
@@ -459,12 +458,11 @@ class Dispatcher:
         return unscheduled_operations
 
     @_dispatcher_cache
-    def scheduled_operations(self) -> List[Operation]:
+    def scheduled_operations(self) -> List[ScheduledOperation]:
         """Returns the list of operations that have been scheduled."""
         scheduled_operations = []
-        for job_id, next_position in enumerate(self._job_next_operation_index):
-            operations = self.instance.jobs[job_id][:next_position]
-            scheduled_operations.extend(operations)
+        for machine_schedule in self.schedule.schedule:
+            scheduled_operations.extend(machine_schedule)
         return scheduled_operations
 
     @_dispatcher_cache
@@ -532,19 +530,14 @@ class Dispatcher:
         return scheduled_operation.end_time - adjusted_start_time
 
     @_dispatcher_cache
-    def completed_operations(self) -> Set[Operation]:
+    def completed_operations(self) -> Set[ScheduledOperation]:
         """Returns the set of operations that have been completed.
 
         This method returns the operations that have been scheduled and the
         current time is greater than or equal to the end time of the operation.
         """
         scheduled_operations = set(self.scheduled_operations())
-        ongoing_operations = set(
-            map(
-                lambda scheduled_op: scheduled_op.operation,
-                self.ongoing_operations(),
-            )
-        )
+        ongoing_operations = set(self.ongoing_operations())
         completed_operations = scheduled_operations - ongoing_operations
         return completed_operations
 

{job_shop_lib-1.0.0b5 → job_shop_lib-1.0.1}/job_shop_lib/dispatching/_factories.py

@@ -95,9 +95,9 @@ def ready_operations_filter_factory(
 
     Args:
         filter_name:
-            The name of the filter function to be used. Supported
-            values are 'dominated_operations' and
-            'immediate_machine_operations'.
+            The name of the filter function to be used. See
+            :class:`ReadyOperationsFilterType` for supported values.
+            Alternatively, a custom filter function can be passed directly.
 
     Returns:
         A function that takes a :class:`~job_shop_lib.dispatching.Dispatcher`

{job_shop_lib-1.0.0b5 → job_shop_lib-1.0.1}/job_shop_lib/dispatching/_optimal_operations_observer.py

@@ -20,8 +20,6 @@ class OptimalOperationsObserver(DispatcherObserver):
             based on the reference schedule.
         reference_schedule: The reference schedule used to determine optimal
             operations.
-        _operation_to_scheduled: Dictionary mapping operations to their
-            scheduled versions in the reference schedule.
 
     Args:
         dispatcher: The dispatcher instance to observe.

{job_shop_lib-1.0.0b5 → job_shop_lib-1.0.1}/job_shop_lib/dispatching/_ready_operation_filters.py

@@ -153,16 +153,16 @@ def _get_min_machine_end_times(
 
 
 def _get_immediate_machines(
-    self: Dispatcher, available_operations: List[Operation]
+    dispatcher: Dispatcher, available_operations: List[Operation]
 ) -> List[bool]:
     """Returns the machine ids of the machines that have at least one
     operation with the lowest start time (i.e. the start time)."""
-    working_machines = [False] * self.instance.num_machines
+    working_machines = [False] * dispatcher.instance.num_machines
     # We can't use the current_time directly because it will cause
     # an infinite loop.
-    current_time = self.min_start_time(available_operations)
+    current_time = dispatcher.min_start_time(available_operations)
     for op in available_operations:
         for machine_id in op.machines:
-            if self.start_time(op, machine_id) == current_time:
+            if dispatcher.start_time(op, machine_id) == current_time:
                 working_machines[machine_id] = True
     return working_machines

{job_shop_lib-1.0.0b5 → job_shop_lib-1.0.1}/job_shop_lib/dispatching/feature_observers/_composite_feature_observer.py

@@ -2,7 +2,7 @@
 
 from collections import defaultdict
 from collections.abc import Sequence
-from typing import List, Dict, Union, Optional
+from typing import List, Dict, Union, Optional, Type
 # The Self type can be imported directly from Python’s typing module in
 # version 3.11 and beyond. We use the typing_extensions module to support
 # python >=3.8
@@ -18,6 +18,7 @@ from job_shop_lib.dispatching.feature_observers import (
     FeatureType,
     FeatureObserverConfig,
     feature_observer_factory,
+    FeatureObserverType,
 )
 
 
@@ -104,7 +105,14 @@ class CompositeFeatureObserver(FeatureObserver):
     def from_feature_observer_configs(
         cls,
         dispatcher: Dispatcher,
-        feature_observer_configs: Sequence[FeatureObserverConfig],
+        feature_observer_configs: Sequence[
+            Union[
+                str,
+                FeatureObserverType,
+                Type[FeatureObserver],
+                FeatureObserverConfig,
+            ],
+        ],
         subscribe: bool = True,
     ) -> Self:
         """Creates the composite feature observer.
@@ -178,9 +186,6 @@ if __name__ == "__main__":
     import time
     from job_shop_lib.benchmarking import load_benchmark_instance
     from job_shop_lib.dispatching.rules import DispatchingRuleSolver
-    from job_shop_lib.dispatching.feature_observers import (
-        FeatureObserverType,
-    )
 
     ta80 = load_benchmark_instance("ta80")
 

{job_shop_lib-1.0.0b5 → job_shop_lib-1.0.1}/job_shop_lib/dispatching/feature_observers/_factory.py

@@ -39,9 +39,14 @@ class FeatureObserverType(str, Enum):
 # FeatureObserverConfig = DispatcherObserverConfig[
 #     Type[FeatureObserver] | FeatureObserverType | str
 # ]
-FeatureObserverConfig = DispatcherObserverConfig[
-    Union[Type[FeatureObserver], FeatureObserverType, str]
-]
+# FeatureObserverConfig = DispatcherObserverConfig[
+#     Union[Type[FeatureObserver], FeatureObserverType, str]
+# ]
+FeatureObserverConfig = (
+    DispatcherObserverConfig[Type[FeatureObserver]]
+    | DispatcherObserverConfig[FeatureObserverType]
+    | DispatcherObserverConfig[str]
+)
 
 
 def feature_observer_factory(

{job_shop_lib-1.0.0b5 → job_shop_lib-1.0.1}/job_shop_lib/dispatching/feature_observers/_feature_observer.py

@@ -36,7 +36,7 @@ class FeatureObserver(DispatcherObserver):
     individually. Furthermore, machine learning models can be trained on these
     arrays to predict the best dispatching decisions.
 
-    Arrays use the data type ``np.float32``. This is because most machine
+    Arrays use the data type ``np.float32``.
 
     New :class:`FeatureObservers` must inherit from this class, and re-define
     the class attributes ``_singleton`` (defualt ), ``_feature_size``

job_shop_lib-1.0.1/job_shop_lib/dispatching/feature_observers/_is_completed_observer.py

@@ -0,0 +1,97 @@
+"""Home of the `IsCompletedObserver` class."""
+
+from typing import Optional, Union, List
+import numpy as np
+
+from job_shop_lib import ScheduledOperation
+from job_shop_lib.dispatching import Dispatcher
+from job_shop_lib.dispatching.feature_observers import (
+    FeatureObserver,
+    FeatureType,
+)
+
+
+class IsCompletedObserver(FeatureObserver):
+    """Adds a binary feature indicating whether each operation,
+    machine, or job has been completed.
+
+    An operation is considered completed if it has been scheduled and the
+    current time is greater than or equal to the sum of the operation's start
+    time and duration.
+
+    A machine or job is considered completed if all of its operations have been
+    completed.
+
+    Args:
+        dispatcher:
+            The :class:`~job_shop_lib.dispatching.Dispatcher` to observe.
+        feature_types:
+            A list of :class:`FeatureType` or a single :class:`FeatureType`
+            that specifies the types of features to observe. They must be a
+            subset of the class attribute :attr:`supported_feature_types`.
+            If ``None``, all supported feature types are tracked.
+        subscribe:
+            If ``True``, the observer is subscribed to the dispatcher upon
+            initialization. Otherwise, the observer must be subscribed later
+            or manually updated.
+    """
+
+    def __init__(
+        self,
+        dispatcher: Dispatcher,
+        *,
+        feature_types: Optional[Union[List[FeatureType], FeatureType]] = None,
+        subscribe: bool = True,
+    ):
+        feature_types = self._get_feature_types_list(feature_types)
+        self._num_of_operations_per_machine = np.array(
+            [
+                len(operations_by_machine)
+                for operations_by_machine in (
+                    dispatcher.instance.operations_by_machine
+                )
+            ]
+        )
+        self._num_of_operations_per_job = np.array(
+            [len(job) for job in dispatcher.instance.jobs]
+        )
+        super().__init__(
+            dispatcher,
+            feature_types=feature_types,
+            subscribe=subscribe,
+        )
+
+    def initialize_features(self):
+        if FeatureType.OPERATIONS in self.features:
+            completed_operations = [
+                op.operation.operation_id
+                for op in self.dispatcher.completed_operations()
+            ]
+            self.features[FeatureType.OPERATIONS][completed_operations, 0] = 1
+        if FeatureType.MACHINES in self.features:
+            num_completed_ops_per_machine = np.zeros(
+                len(self._num_of_operations_per_machine)
+            )
+            for op in self.dispatcher.completed_operations():
+                for machine_id in op.operation.machines:
+                    num_completed_ops_per_machine[machine_id] += 1
+            self.features[FeatureType.MACHINES][:, 0] = (
+                num_completed_ops_per_machine
+                == self._num_of_operations_per_machine
+            ).astype(np.float32)
+        if FeatureType.JOBS in self.features:
+            num_completed_ops_per_job = np.zeros(
+                len(self._num_of_operations_per_job)
+            )
+            for op in self.dispatcher.completed_operations():
+                num_completed_ops_per_job[op.operation.job_id] += 1
+            self.features[FeatureType.JOBS][:, 0] = (
+                num_completed_ops_per_job
+                == self._num_of_operations_per_job
+            ).astype(np.float32)
+
+    def reset(self):
+        self.set_features_to_zero()
+
+    def update(self, scheduled_operation: ScheduledOperation):
+        self.initialize_features()

{job_shop_lib-1.0.0b5 → job_shop_lib-1.0.1}/job_shop_lib/dispatching/rules/_dispatching_rule_factory.py

@@ -33,7 +33,7 @@ class DispatchingRuleType(str, Enum):
 
 
 def dispatching_rule_factory(
-    dispatching_rule: Union[str, DispatchingRuleType,]
+    dispatching_rule: Union[str, DispatchingRuleType],
 ) -> Callable[[Dispatcher], Operation]:
     """Creates and returns a dispatching rule function based on the specified
     dispatching rule name.

{job_shop_lib-1.0.0b5 → job_shop_lib-1.0.1}/job_shop_lib/dispatching/rules/_machine_chooser_factory.py

@@ -47,8 +47,9 @@ def machine_chooser_factory(
         machine chooser strategy.
 
     Raises:
-        ValueError: If the machine_chooser argument is not recognized or is
-            not supported.
+        ValidationError:
+            If the ``machine_chooser`` argument is not recognized or
+            is not supported.
     """
     machine_choosers: Dict[str, Callable[[Dispatcher, Operation], int]] = {
         MachineChooserType.FIRST: lambda _, operation: operation.machines[0],

{job_shop_lib-1.0.0b5 → job_shop_lib-1.0.1}/job_shop_lib/graphs/__init__.py

@@ -38,6 +38,7 @@ from job_shop_lib.graphs._build_resource_task_graphs import (
     add_global_node,
     add_machine_global_edges,
     add_job_global_edges,
+    add_job_job_edges,
 )
 
 
@@ -65,4 +66,5 @@ __all__ = [
     "add_machine_global_edges",
     "add_job_global_edges",
     "build_solved_disjunctive_graph",
+    "add_job_job_edges",
 ]

{job_shop_lib-1.0.0b5 → job_shop_lib-1.0.1}/job_shop_lib/graphs/_build_resource_task_graphs.py

@@ -1,7 +1,7 @@
 """Contains helper functions to build the resource-task graphs from a job shop
 instance.
 
-The agent-task graph (renamed to resource-task graph) was introduced by
+The resource-task graph (originally called agent-task graph) was introduced by
 Junyoung Park et al. (2021).
 In contrast to the disjunctive graph, instead of connecting operations that
 share the same resources directly by disjunctive edges, operation nodes are

{job_shop_lib-1.0.0b5 → job_shop_lib-1.0.1}/job_shop_lib/graphs/_job_shop_graph.py

@@ -132,15 +132,13 @@ class JobShopGraph:
 
         This method assigns a unique identifier to the node, adds it to the
         graph, and updates the nodes list and the nodes_by_type dictionary. If
-        the node is of type `OPERATION`, it also updates `nodes_by_job` and
-        `nodes_by_machine` based on the operation's job_id and machine_ids.
+        the node is of type :class:`NodeType.OPERATION`, it also updates
+        ``nodes_by_job`` and ``nodes_by_machine`` based on the operation's
+        job id and machine ids.
 
         Args:
-            node_for_adding (Node): The node to be added to the graph.
-
-        Raises:
-            ValueError: If the node type is unsupported or if required
-            attributes for the node type are missing.
+            node_for_adding:
+                The node to be added to the graph.
 
         Note:
             This method directly modifies the graph attribute as well as
@@ -171,17 +169,25 @@ class JobShopGraph:
     ) -> None:
         """Adds an edge to the graph.
 
+        It automatically determines the edge type based on the source and
+        destination nodes unless explicitly provided in the ``attr`` argument
+        via the ``type`` key. The edge type is a tuple of strings:
+        ``(source_node_type, "to", destination_node_type)``.
+
         Args:
-            u_of_edge: The source node of the edge. If it is a `Node`, its
-                `node_id` is used as the source. Otherwise, it is assumed to be
-                the node_id of the source.
-            v_of_edge: The destination node of the edge. If it is a `Node`, its
-                `node_id` is used as the destination. Otherwise, it is assumed
-                to be the node_id of the destination.
-            **attr: Additional attributes to be added to the edge.
+            u_of_edge:
+                The source node of the edge. If it is a :class:`Node`, its
+                ``node_id`` is used as the source. Otherwise, it is assumed to
+                be the ``node_id`` of the source.
+            v_of_edge:
+                The destination node of the edge. If it is a :class:`Node`,
+                its ``node_id`` is used as the destination. Otherwise, it
+                is assumed to be the ``node_id`` of the destination.
+            **attr:
+                Additional attributes to be added to the edge.
 
         Raises:
-            ValidationError: If `u_of_edge` or `v_of_edge` are not in the
+            ValidationError: If ``u_of_edge`` or ``v_of_edge`` are not in the
                 graph.
         """
         if isinstance(u_of_edge, Node):
@@ -192,18 +198,30 @@ class JobShopGraph:
             raise ValidationError(
                 "`u_of_edge` and `v_of_edge` must be in the graph."
             )
-        self.graph.add_edge(u_of_edge, v_of_edge, **attr)
+        edge_type = attr.pop("type", None)
+        if edge_type is None:
+            u_node = self.nodes[u_of_edge]
+            v_node = self.nodes[v_of_edge]
+            edge_type = (
+                u_node.node_type.name.lower(),
+                "to",
+                v_node.node_type.name.lower(),
+            )
+        self.graph.add_edge(u_of_edge, v_of_edge, type=edge_type, **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.
+            node_id:
+                The id of the node to remove.
         """
         self.graph.remove_node(node_id)
         self.removed_nodes[node_id] = True
 
+    def remove_isolated_nodes(self) -> None:
+        """Removes isolated nodes from the graph."""
         isolated_nodes = list(nx.isolates(self.graph))
         for isolated_node in isolated_nodes:
             self.removed_nodes[isolated_node] = True
@@ -214,9 +232,10 @@ class JobShopGraph:
         """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
+            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.
+                ``node_id`` of the node to check.
         """
         if isinstance(node, Node):
             node = node.node_id

{job_shop_lib-1.0.0b5 → job_shop_lib-1.0.1}/job_shop_lib/graphs/graph_updaters/__init__.py

@@ -7,6 +7,7 @@ Currently, the following classes and utilities are available:
 
     GraphUpdater
     ResidualGraphUpdater
+    DisjunctiveGraphUpdater
     remove_completed_operations
 
 """
@@ -14,10 +15,12 @@ Currently, the following classes and utilities are available:
 from ._graph_updater import GraphUpdater
 from ._utils import remove_completed_operations
 from ._residual_graph_updater import ResidualGraphUpdater
+from ._disjunctive_graph_updater import DisjunctiveGraphUpdater
 
 
 __all__ = [
     "GraphUpdater",
     "remove_completed_operations",
     "ResidualGraphUpdater",
+    "DisjunctiveGraphUpdater",
 ]

job_shop_lib-1.0.1/job_shop_lib/graphs/graph_updaters/_disjunctive_graph_updater.py

@@ -0,0 +1,108 @@
+"""Home of the `ResidualGraphUpdater` class."""
+
+from job_shop_lib import ScheduledOperation
+from job_shop_lib.graphs.graph_updaters import (
+    ResidualGraphUpdater,
+)
+from job_shop_lib.exceptions import ValidationError
+
+
+class DisjunctiveGraphUpdater(ResidualGraphUpdater):
+    """Updates the graph based on the completed operations.
+
+    This observer updates the graph by removing the completed
+    operation, machine and job nodes from the graph. It subscribes to the
+    :class:`~job_shop_lib.dispatching.feature_observers.IsCompletedObserver`
+    to determine which operations, machines and jobs have been completed.
+
+    After an operation is dispatched, one of two disjunctive arcs that
+    connected it with the previous operation is dropped. Similarly, the
+    disjunctive arcs associated with the previous scheduled operation are
+    removed.
+
+    Attributes:
+        remove_completed_machine_nodes:
+            If ``True``, removes completed machine nodes from the graph.
+        remove_completed_job_nodes:
+            If ``True``, removes completed job nodes from the graph.
+
+    Args:
+        dispatcher:
+            The dispatcher instance to observe.
+        job_shop_graph:
+            The job shop graph to update.
+        subscribe:
+            If ``True``, automatically subscribes the observer to the
+            dispatcher. Defaults to ``True``.
+        remove_completed_machine_nodes:
+            If ``True``, removes completed machine nodes from the graph.
+            Defaults to ``True``.
+        remove_completed_job_nodes:
+            If ``True``, removes completed job nodes from the graph.
+            Defaults to ``True``.
+    """
+
+    def update(self, scheduled_operation: ScheduledOperation) -> None:
+        """Updates the disjunctive graph.
+
+        After an operation is dispatched, one of two arcs that connected it
+        with the previous operation is dropped. Similarly, the disjunctive
+        arcs associated with the previous scheduled operation are removed.
+
+        Args:
+            scheduled_operation:
+                The scheduled operation that was dispatched.
+        """
+        super().update(scheduled_operation)
+        machine_schedule = self.dispatcher.schedule.schedule[
+            scheduled_operation.machine_id
+        ]
+        if len(machine_schedule) <= 1:
+            return
+
+        previous_scheduled_operation = machine_schedule[-2]
+
+        # Remove the disjunctive arcs between the scheduled operation and the
+        # previous operation
+        scheduled_operation_node = self.job_shop_graph.nodes[
+            scheduled_operation.operation.operation_id
+        ]
+        if (
+            scheduled_operation_node.operation
+            is not scheduled_operation.operation
+        ):
+            raise ValidationError(
+                "Scheduled operation node does not match scheduled operation."
+                "Make sure that the operation nodes have been the first to be "
+                "added to the graph. This method assumes that the operation id"
+                " and node id are the same."
+            )
+        scheduled_id = scheduled_operation_node.node_id
+        assert scheduled_id == scheduled_operation.operation.operation_id
+        previous_id = previous_scheduled_operation.operation.operation_id
+        if self.job_shop_graph.is_removed(
+            previous_id
+        ) or self.job_shop_graph.is_removed(scheduled_id):
+            return
+        self.job_shop_graph.graph.remove_edge(scheduled_id, previous_id)
+
+        # Now, remove all the disjunctive edges between the previous scheduled
+        # operation and the other operations in the machine schedule
+        operations_with_same_machine = (
+            self.dispatcher.instance.operations_by_machine[
+                scheduled_operation.machine_id
+            ]
+        )
+        already_scheduled_operations = {
+            scheduled_op.operation.operation_id
+            for scheduled_op in machine_schedule
+        }
+        for operation in operations_with_same_machine:
+            if operation.operation_id in already_scheduled_operations:
+                continue
+            self.job_shop_graph.graph.remove_edge(
+                previous_id, operation.operation_id
+            )
+            self.job_shop_graph.graph.remove_edge(
+                operation.operation_id, previous_id
+            )