job-shop-lib 1.0.0b5__py3-none-any.whl → 1.0.2__py3-none-any.whl

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/graphs/graph_updaters/__init__.py

@@ -4,9 +4,11 @@ job shop scheduling problem.
 Currently, the following classes and utilities are available:
 
 .. autosummary::
+    :nosignatures:
 
     GraphUpdater
     ResidualGraphUpdater
+    DisjunctiveGraphUpdater
     remove_completed_operations
 
 """
@@ -14,10 +16,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",
+    "remove_completed_operations",
 ]

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
+            )

job_shop_lib/graphs/graph_updaters/_residual_graph_updater.py

@@ -112,7 +112,9 @@ class ResidualGraphUpdater(GraphUpdater):
         """Updates the residual graph based on the completed operations."""
         remove_completed_operations(
             self.job_shop_graph,
-            completed_operations=self.dispatcher.completed_operations(),
+            completed_operations=(
+                op.operation for op in self.dispatcher.completed_operations()
+            ),
         )
         graph_has_machine_nodes = bool(
             self.job_shop_graph.nodes_by_type[NodeType.MACHINE]

job_shop_lib/graphs/graph_updaters/_utils.py

@@ -1,4 +1,4 @@
-"""Contains grah updater functions to update """
+"""Contains utility functions for updating the job shop graph."""
 
 from collections.abc import Iterable
 
@@ -13,7 +13,7 @@ def remove_completed_operations(
     """Removes the operation node of the scheduled operation from the graph.
 
     Args:
-        graph:
+        job_shop_graph:
             The job shop graph to update.
         dispatcher:
             The dispatcher instance.

job_shop_lib/reinforcement_learning/__init__.py

@@ -1,20 +1,24 @@
 """Contains reinforcement learning components.
 
 
+
 .. autosummary::
+    :nosignatures:
 
     SingleJobShopGraphEnv
     MultiJobShopGraphEnv
     ObservationDict
     ObservationSpaceKey
+    ResourceTaskGraphObservation
+    ResourceTaskGraphObservationDict
     RewardObserver
     MakespanReward
     IdleTimeReward
     RenderConfig
     add_padding
     create_edge_type_dict
-    ResourceTaskGraphObservation
-    ResourceTaskGraphObservationDict
+    map_values
+    get_optimal_actions
 
 """
 
@@ -34,6 +38,7 @@ from job_shop_lib.reinforcement_learning._utils import (
     add_padding,
     create_edge_type_dict,
     map_values,
+    get_optimal_actions,
 )
 
 from job_shop_lib.reinforcement_learning._single_job_shop_graph_env import (
@@ -48,17 +53,18 @@ from ._resource_task_graph_observation import (
 
 
 __all__ = [
+    "SingleJobShopGraphEnv",
+    "MultiJobShopGraphEnv",
+    "ObservationDict",
     "ObservationSpaceKey",
+    "ResourceTaskGraphObservation",
+    "ResourceTaskGraphObservationDict",
     "RewardObserver",
     "MakespanReward",
     "IdleTimeReward",
-    "SingleJobShopGraphEnv",
     "RenderConfig",
-    "ObservationDict",
     "add_padding",
-    "MultiJobShopGraphEnv",
     "create_edge_type_dict",
-    "ResourceTaskGraphObservation",
     "map_values",
-    "ResourceTaskGraphObservationDict",
+    "get_optimal_actions",
 ]

job_shop_lib/reinforcement_learning/_multi_job_shop_graph_env.py

@@ -117,7 +117,7 @@ class MultiJobShopGraphEnv(gym.Env):
         graph_initializer:
             Function to create the initial graph representation.
             If ``None``, the default graph initializer is used:
-            :func:`~job_shop_lib.graphs.build_agent_task_graph`.
+            :func:`~job_shop_lib.graphs.build_resource_task_graph`.
         graph_updater_config:
             Configuration for the graph updater. The graph updater is used
             to update the graph representation after each action. If

job_shop_lib/reinforcement_learning/_resource_task_graph_observation.py

@@ -1,6 +1,6 @@
 """Contains wrappers for the environments."""
 
-from typing import TypeVar, TypedDict, Generic
+from typing import TypeVar, TypedDict, Generic, Any
 from gymnasium import ObservationWrapper
 import numpy as np
 from numpy.typing import NDArray
@@ -20,11 +20,22 @@ EnvType = TypeVar(  # pylint: disable=invalid-name
     "EnvType", bound=SingleJobShopGraphEnv | MultiJobShopGraphEnv
 )
 
+_NODE_TYPE_TO_FEATURE_TYPE = {
+    NodeType.OPERATION: FeatureType.OPERATIONS,
+    NodeType.MACHINE: FeatureType.MACHINES,
+    NodeType.JOB: FeatureType.JOBS,
+}
+_FEATURE_TYPE_STR_TO_NODE_TYPE = {
+    FeatureType.OPERATIONS.value: NodeType.OPERATION,
+    FeatureType.MACHINES.value: NodeType.MACHINE,
+    FeatureType.JOBS.value: NodeType.JOB,
+}
+
 
 class ResourceTaskGraphObservationDict(TypedDict):
     """Represents a dictionary for resource task graph observations."""
 
-    edge_index_dict: dict[str, NDArray[np.int64]]
+    edge_index_dict: dict[tuple[str, str, str], NDArray[np.int32]]
     node_features_dict: dict[str, NDArray[np.float32]]
     original_ids_dict: dict[str, NDArray[np.int32]]
 
@@ -40,6 +51,12 @@ class ResourceTaskGraphObservation(ObservationWrapper, Generic[EnvType]):
     ``node_type_j`` are the node types of the source and target nodes,
     respectively.
 
+    Additionally, the node features are stored in a dictionary with keys
+    corresponding to the node type names under the ``node_features_dict`` key.
+
+    The node IDs are mapped to local IDs starting from 0. The
+    ``original_ids_dict`` contains the original node IDs before removing nodes.
+
     Attributes:
         global_to_local_id: A dictionary mapping global node IDs to local node
             IDs for each node type.
@@ -55,6 +72,7 @@ class ResourceTaskGraphObservation(ObservationWrapper, Generic[EnvType]):
         self.env = env  # Unnecessary, but makes mypy happy
         self.global_to_local_id = self._compute_id_mappings()
         self.type_ranges = self._compute_node_type_ranges()
+        self._start_from_zero_mapping: dict[str, dict[int, int]] = {}
 
     def step(self, action: tuple[int, int]):
         """Takes a step in the environment.
@@ -80,7 +98,9 @@ class ResourceTaskGraphObservation(ObservationWrapper, Generic[EnvType]):
               machine_id, job_id).
         """
         observation, reward, done, truncated, info = self.env.step(action)
-        return self.observation(observation), reward, done, truncated, info
+        new_observation = self.observation(observation)
+        new_info = self._info(info)
+        return new_observation, reward, done, truncated, new_info
 
     def reset(self, *, seed: int | None = None, options: dict | None = None):
         """Resets the environment.
@@ -104,7 +124,34 @@ class ResourceTaskGraphObservation(ObservationWrapper, Generic[EnvType]):
                 (operation_id, machine_id, job_id).
         """
         observation, info = self.env.reset()
-        return self.observation(observation), info
+        new_observation = self.observation(observation)
+        new_info = self._info(info)
+        return new_observation, new_info
+
+    def _info(self, info: dict[str, Any]) -> dict[str, Any]:
+        """Updates the "available_operations_with_ids" key in the info
+        dictionary so that they start from 0 using the
+        `_start_from_zero_mapping` attribute.
+        """
+        new_available_operations_ids = []
+        for operation_id, machine_id, job_id in info[
+            "available_operations_with_ids"
+        ]:
+            if "operation" in self._start_from_zero_mapping:
+                operation_id = self._start_from_zero_mapping["operation"][
+                    operation_id
+                ]
+            if "machine" in self._start_from_zero_mapping:
+                machine_id = self._start_from_zero_mapping["machine"][
+                    machine_id
+                ]
+            if "job" in self._start_from_zero_mapping:
+                job_id = self._start_from_zero_mapping["job"][job_id]
+            new_available_operations_ids.append(
+                (operation_id, machine_id, job_id)
+            )
+        info["available_operations_with_ids"] = new_available_operations_ids
+        return info
 
     def _compute_id_mappings(self) -> dict[int, int]:
         """Computes mappings from global node IDs to type-local IDs.
@@ -145,21 +192,50 @@ class ResourceTaskGraphObservation(ObservationWrapper, Generic[EnvType]):
 
         return type_ranges
 
-    def observation(self, observation: ObservationDict):
+    def observation(
+        self, observation: ObservationDict
+    ) -> ResourceTaskGraphObservationDict:
+        """Processes the observation data into the resource task graph format.
+
+        Args:
+            observation: The observation dictionary. It must NOT have padding.
+
+        Returns:
+            A dictionary containing the following keys:
+
+            - "edge_index_dict": A dictionary mapping edge types to edge index
+              arrays.
+            - "node_features_dict": A dictionary mapping node type names to
+                node feature arrays.
+            - "original_ids_dict": A dictionary mapping node type names to the
+              original node IDs before removing nodes.
+        """
         edge_index_dict = create_edge_type_dict(
             observation["edge_index"],
             type_ranges=self.type_ranges,
             relationship="to",
         )
+        node_features_dict = self._create_node_features_dict(observation)
+        node_features_dict, original_ids_dict = self._remove_nodes(
+            node_features_dict, observation["removed_nodes"]
+        )
+
         # mapping from global node ID to local node ID
         for key, edge_index in edge_index_dict.items():
             edge_index_dict[key] = map_values(
                 edge_index, self.global_to_local_id
             )
-        node_features_dict = self._create_node_features_dict(observation)
-        node_features_dict, original_ids_dict = self._remove_nodes(
-            node_features_dict, observation["removed_nodes"]
+        # mapping so that ids start from 0 in edge index
+        self._start_from_zero_mapping = self._get_start_from_zero_mappings(
+            original_ids_dict
         )
+        for (type_1, to, type_2), edge_index in edge_index_dict.items():
+            edge_index_dict[(type_1, to, type_2)][0] = map_values(
+                edge_index[0], self._start_from_zero_mapping[type_1]
+            )
+            edge_index_dict[(type_1, to, type_2)][1] = map_values(
+                edge_index[1], self._start_from_zero_mapping[type_2]
+            )
 
         return {
             "edge_index_dict": edge_index_dict,
@@ -167,6 +243,15 @@ class ResourceTaskGraphObservation(ObservationWrapper, Generic[EnvType]):
             "original_ids_dict": original_ids_dict,
         }
 
+    @staticmethod
+    def _get_start_from_zero_mappings(
+        original_indices_dict: dict[str, NDArray[np.int32]]
+    ) -> dict[str, dict[int, int]]:
+        mappings = {}
+        for key, indices in original_indices_dict.items():
+            mappings[key] = {idx: i for i, idx in enumerate(indices)}
+        return mappings
+
     def _create_node_features_dict(
         self, observation: ObservationDict
     ) -> dict[str, NDArray]:
@@ -178,14 +263,10 @@ class ResourceTaskGraphObservation(ObservationWrapper, Generic[EnvType]):
         Returns:
             Dictionary mapping node type names to node features.
         """
-        node_type_to_feature_type = {
-            NodeType.OPERATION: FeatureType.OPERATIONS,
-            NodeType.MACHINE: FeatureType.MACHINES,
-            NodeType.JOB: FeatureType.JOBS,
-        }
+
         node_features_dict = {}
-        for node_type, feature_type in node_type_to_feature_type.items():
-            if node_type in self.unwrapped.job_shop_graph.nodes_by_type:
+        for node_type, feature_type in _NODE_TYPE_TO_FEATURE_TYPE.items():
+            if self.unwrapped.job_shop_graph.nodes_by_type[node_type]:
                 node_features_dict[feature_type.value] = observation[
                     feature_type.value
                 ]
@@ -211,9 +292,9 @@ class ResourceTaskGraphObservation(ObservationWrapper, Generic[EnvType]):
 
     def _remove_nodes(
         self,
-        node_features_dict: dict[str, NDArray[np.float32]],
+        node_features_dict: dict[str, NDArray[T]],
         removed_nodes: NDArray[np.bool_],
-    ) -> tuple[dict[str, NDArray[np.float32]], dict[str, NDArray[np.int32]]]:
+    ) -> tuple[dict[str, NDArray[T]], dict[str, NDArray[np.int32]]]:
         """Removes nodes from the node features dictionary.
 
         Args:
@@ -223,15 +304,12 @@ class ResourceTaskGraphObservation(ObservationWrapper, Generic[EnvType]):
             The node features dictionary with the nodes removed and a
             dictionary containing the original node ids.
         """
-        removed_nodes_dict: dict[str, NDArray[np.float32]] = {}
+        removed_nodes_dict: dict[str, NDArray[T]] = {}
         original_ids_dict: dict[str, NDArray[np.int32]] = {}
-        feature_type_to_node_type = {
-            FeatureType.OPERATIONS.value: NodeType.OPERATION,
-            FeatureType.MACHINES.value: NodeType.MACHINE,
-            FeatureType.JOBS.value: NodeType.JOB,
-        }
         for feature_type, features in node_features_dict.items():
-            node_type = feature_type_to_node_type[feature_type].name.lower()
+            node_type = _FEATURE_TYPE_STR_TO_NODE_TYPE[
+                feature_type
+            ].name.lower()
             if node_type not in self.type_ranges:
                 continue
             start, end = self.type_ranges[node_type]

job_shop_lib/reinforcement_learning/_single_job_shop_graph_env.py

@@ -2,7 +2,7 @@
 
 from copy import deepcopy
 from collections.abc import Callable, Sequence
-from typing import Any, Dict, Tuple, List, Optional, Type
+from typing import Any, Dict, Tuple, List, Optional, Type, Union
 
 import matplotlib.pyplot as plt
 import gymnasium as gym
@@ -24,6 +24,8 @@ from job_shop_lib.dispatching import (
 from job_shop_lib.dispatching.feature_observers import (
     FeatureObserverConfig,
     CompositeFeatureObserver,
+    FeatureObserver,
+    FeatureObserverType,
 )
 from job_shop_lib.visualization.gantt import GanttChartCreator
 from job_shop_lib.reinforcement_learning import (
@@ -137,7 +139,14 @@ class SingleJobShopGraphEnv(gym.Env):
     def __init__(
         self,
         job_shop_graph: JobShopGraph,
-        feature_observer_configs: Sequence[FeatureObserverConfig],
+        feature_observer_configs: Sequence[
+            Union[
+                str,
+                FeatureObserverType,
+                Type[FeatureObserver],
+                FeatureObserverConfig,
+            ],
+        ],
         reward_function_config: DispatcherObserverConfig[
             Type[RewardObserver]
         ] = DispatcherObserverConfig(class_type=MakespanReward),

job_shop_lib/reinforcement_learning/_types_and_constants.py

@@ -5,6 +5,7 @@ from enum import Enum
 from typing import TypedDict
 
 import numpy as np
+from numpy.typing import NDArray
 
 from job_shop_lib.dispatching.feature_observers import FeatureType
 from job_shop_lib.visualization.gantt import (
@@ -35,27 +36,27 @@ class ObservationSpaceKey(str, Enum):
 class _ObservationDictRequired(TypedDict):
     """Required fields for the observation dictionary."""
 
-    removed_nodes: np.ndarray
-    edge_index: np.ndarray
+    removed_nodes: NDArray[np.bool_]
+    edge_index: NDArray[np.int32]
 
 
 class _ObservationDictOptional(TypedDict, total=False):
     """Optional fields for the observation dictionary."""
 
-    operations: np.ndarray
-    jobs: np.ndarray
-    machines: np.ndarray
+    operations: NDArray[np.float32]
+    jobs: NDArray[np.float32]
+    machines: NDArray[np.float32]
 
 
 class ObservationDict(_ObservationDictRequired, _ObservationDictOptional):
     """A dictionary containing the observation of the environment.
 
     Required fields:
-        removed_nodes (np.ndarray): Binary vector indicating removed nodes.
-        edge_index (np.ndarray): Edge list in COO format.
+        removed_nodes: Binary vector indicating removed nodes.
+        edge_index: Edge list in COO format.
 
     Optional fields:
-        operations (np.ndarray): Matrix of operation features.
-        jobs (np.ndarray): Matrix of job features.
-        machines (np.ndarray): Matrix of machine features.
+        operations: Matrix of operation features.
+        jobs: Matrix of job features.
+        machines: Matrix of machine features.
     """

job_shop_lib/reinforcement_learning/_utils.py

@@ -6,6 +6,7 @@ import numpy as np
 from numpy.typing import NDArray
 
 from job_shop_lib.exceptions import ValidationError
+from job_shop_lib.dispatching import OptimalOperationsObserver
 
 T = TypeVar("T", bound=np.number)
 
@@ -164,6 +165,34 @@ def map_values(array: NDArray[T], mapping: dict[int, int]) -> NDArray[T]:
         ) from e
 
 
+def get_optimal_actions(
+    optimal_ops_observer: OptimalOperationsObserver,
+    available_operations_with_ids: list[tuple[int, int, int]],
+) -> dict[tuple[int, int, int], int]:
+    """Indicates if each action is optimal according to a
+    :class:`~job_shop_lib.dispatching.OptimalOperationsObserver` instance.
+
+    Args:
+        optimal_ops_observer: The observer that provides optimal operations.
+        available_operations_with_ids: List of available operations with their
+        IDs (operation_id, machine_id, job_id).
+
+    Returns:
+        A dictionary mapping each tuple
+        (operation_id, machine_id, job_id) in the available actions to a binary
+        indicator (1 if optimal, 0 otherwise).
+    """
+    optimal_actions = {}
+    optimal_ops = optimal_ops_observer.optimal_available
+    optimal_ops_ids = [
+        (op.operation_id, op.machine_id, op.job_id) for op in optimal_ops
+    ]
+    for operation_id, machine_id, job_id in available_operations_with_ids:
+        is_optimal = (operation_id, machine_id, job_id) in optimal_ops_ids
+        optimal_actions[(operation_id, machine_id, job_id)] = int(is_optimal)
+    return optimal_actions
+
+
 if __name__ == "__main__":
     import doctest