job-shop-lib 0.5.0__py3-none-any.whl → 1.0.0__py3-none-any.whl

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/_graph_updater.py

@@ -0,0 +1,57 @@
+"""Home of the `GraphUpdater` class."""
+
+from abc import abstractmethod
+from copy import deepcopy
+
+from job_shop_lib import ScheduledOperation
+from job_shop_lib.dispatching import DispatcherObserver, Dispatcher
+from job_shop_lib.graphs import JobShopGraph
+
+
+class GraphUpdater(DispatcherObserver):
+    """Observer that builds and updates a job shop graph.
+
+    This observer uses a provided graph builder function to initialize the
+    job shop graph and a graph updater function to update the graph after
+    each scheduled operation.
+
+    Attributes:
+        initial_job_shop_graph:
+            The initial job shop graph. This is a copy of the graph that was
+            received when the observer was created. It is used to reset the
+            graph to its initial state.
+        job_shop_graph:
+            The current job shop graph. This is the graph that is updated
+            after each scheduled operation.
+
+    Args:
+        dispatcher:
+            The dispatcher instance to observe.
+        job_shop_graph:
+            The job shop graph to update.
+        subscribe:
+            Whether to subscribe to the dispatcher. If ``True``, the
+            observer will subscribe to the dispatcher when it is
+            initialized. If ``False``, the observer will not subscribe
+            to the dispatcher.
+    """
+
+    def __init__(
+        self,
+        dispatcher: Dispatcher,
+        job_shop_graph: JobShopGraph,
+        *,
+        subscribe: bool = True,
+    ):
+        super().__init__(dispatcher, subscribe=subscribe)
+        self.initial_job_shop_graph = deepcopy(job_shop_graph)
+        self.job_shop_graph = job_shop_graph
+
+    def reset(self) -> None:
+        """Resets the job shop graph."""
+        self.job_shop_graph = deepcopy(self.initial_job_shop_graph)
+
+    @abstractmethod
+    def update(self, scheduled_operation: ScheduledOperation) -> None:
+        """Updates the job shop graph after an operation has been
+        dispatched."""

job_shop_lib/graphs/graph_updaters/_residual_graph_updater.py

@@ -0,0 +1,155 @@
+"""Home of the `ResidualGraphUpdater` class."""
+
+from typing import Optional, List
+
+from job_shop_lib import ScheduledOperation
+from job_shop_lib.exceptions import UninitializedAttributeError
+from job_shop_lib.graphs import NodeType, JobShopGraph
+from job_shop_lib.graphs.graph_updaters import (
+    GraphUpdater,
+    remove_completed_operations,
+)
+from job_shop_lib.dispatching import Dispatcher
+from job_shop_lib.dispatching.feature_observers import (
+    IsCompletedObserver,
+    FeatureType,
+)
+from job_shop_lib.dispatching import DispatcherObserver
+
+
+class ResidualGraphUpdater(GraphUpdater):
+    """Updates the residual graph based on the completed operations.
+
+    This observer updates the residual 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.
+
+    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 __init__(
+        self,
+        dispatcher: Dispatcher,
+        job_shop_graph: JobShopGraph,
+        *,
+        subscribe: bool = True,
+        remove_completed_machine_nodes: bool = True,
+        remove_completed_job_nodes: bool = True,
+    ):
+        self._is_completed_observer: Optional[IsCompletedObserver] = None
+        self.remove_completed_job_nodes = remove_completed_job_nodes
+        self.remove_completed_machine_nodes = remove_completed_machine_nodes
+        self._initialize_is_completed_observer_attribute(dispatcher)
+
+        # It is important to initialize the `IsCompletedObserver` before
+        # calling the parent class constructor to ensure the observer is
+        # updated before the `update` method of this class is called.
+        super().__init__(
+            dispatcher,
+            job_shop_graph,
+            subscribe=subscribe,
+        )
+
+    def _initialize_is_completed_observer_attribute(
+        self, dispatcher: Dispatcher
+    ):
+        def has_all_features(observer: DispatcherObserver) -> bool:
+            if not isinstance(observer, IsCompletedObserver):
+                return False  # Make the type checker happy.
+
+            for feature_type in feature_types:
+                if feature_type not in observer.features.keys():
+                    return False
+            return True
+
+        feature_types: List[FeatureType] = []
+        if self.remove_completed_machine_nodes:
+            feature_types.append(FeatureType.MACHINES)
+        if self.remove_completed_job_nodes:
+            feature_types.append(FeatureType.JOBS)
+        if feature_types:
+            self._is_completed_observer = dispatcher.create_or_get_observer(
+                IsCompletedObserver,
+                condition=has_all_features,
+                feature_types=feature_types,
+            )
+
+    @property
+    def is_completed_observer(self) -> IsCompletedObserver:
+        """Returns the :class:`~job_shop_lib.dispatching.feature_observers.
+        IsCompletedObserver` instance."""
+
+        if self._is_completed_observer is None:
+            raise UninitializedAttributeError(
+                "The `is_completed_observer` attribute has not been "
+                "initialized. Set `remove_completed_machine_nodes` or "
+                "remove_completed_job_nodes` to True when initializing the "
+                "ResidualGraphUpdater."
+            )
+        return self._is_completed_observer
+
+    def update(self, scheduled_operation: ScheduledOperation) -> None:
+        """Updates the residual graph based on the completed operations."""
+        remove_completed_operations(
+            self.job_shop_graph,
+            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]
+        )
+        if self.remove_completed_machine_nodes and graph_has_machine_nodes:
+            self._remove_completed_machine_nodes()
+
+        graph_has_machine_nodes = bool(
+            self.job_shop_graph.nodes_by_type[NodeType.JOB]
+        )
+        if self.remove_completed_job_nodes and graph_has_machine_nodes:
+            self._remove_completed_job_nodes()
+
+    def _remove_completed_machine_nodes(self):
+        """Removes the completed machine nodes from the graph if they are
+        not already removed."""
+
+        for machine_id, is_completed in enumerate(
+            self.is_completed_observer.features[FeatureType.MACHINES].flatten()
+        ):
+            if is_completed == 1 and not self.job_shop_graph.is_removed(
+                machine_node := self.job_shop_graph.get_machine_node(
+                    machine_id
+                )
+            ):
+                self.job_shop_graph.remove_node(machine_node.node_id)
+
+    def _remove_completed_job_nodes(self):
+        """Removes the completed job nodes from the graph if they are not
+        already removed."""
+
+        for job_id, is_completed in enumerate(
+            self.is_completed_observer.features[FeatureType.JOBS]
+        ):
+            if is_completed == 1 and not self.job_shop_graph.is_removed(
+                job_node := self.job_shop_graph.get_job_node(job_id)
+            ):
+                self.job_shop_graph.remove_node(job_node.node_id)

job_shop_lib/graphs/graph_updaters/_utils.py

@@ -0,0 +1,25 @@
+"""Contains utility functions for updating the job shop graph."""
+
+from collections.abc import Iterable
+
+from job_shop_lib import Operation
+from job_shop_lib.graphs import JobShopGraph
+
+
+def remove_completed_operations(
+    job_shop_graph: JobShopGraph,
+    completed_operations: Iterable[Operation],
+) -> None:
+    """Removes the operation node of the scheduled operation from the graph.
+
+    Args:
+        job_shop_graph:
+            The job shop graph to update.
+        dispatcher:
+            The dispatcher instance.
+    """
+    for operation in completed_operations:
+        node_id = operation.operation_id
+        if job_shop_graph.removed_nodes[node_id]:
+            continue
+        job_shop_graph.remove_node(node_id)

job_shop_lib/reinforcement_learning/__init__.py

@@ -0,0 +1,68 @@
+"""Contains reinforcement learning components.
+
+
+.. autosummary::
+
+    SingleJobShopGraphEnv
+    MultiJobShopGraphEnv
+    ObservationDict
+    ObservationSpaceKey
+    RewardObserver
+    MakespanReward
+    IdleTimeReward
+    RenderConfig
+    add_padding
+    create_edge_type_dict
+    map_values
+    get_optimal_actions
+    ResourceTaskGraphObservation
+    ResourceTaskGraphObservationDict
+
+"""
+
+from job_shop_lib.reinforcement_learning._types_and_constants import (
+    ObservationSpaceKey,
+    RenderConfig,
+    ObservationDict,
+)
+
+from job_shop_lib.reinforcement_learning._reward_observers import (
+    RewardObserver,
+    MakespanReward,
+    IdleTimeReward,
+)
+
+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 (
+    SingleJobShopGraphEnv,
+)
+from job_shop_lib.reinforcement_learning._multi_job_shop_graph_env import (
+    MultiJobShopGraphEnv,
+)
+from ._resource_task_graph_observation import (
+    ResourceTaskGraphObservation, ResourceTaskGraphObservationDict
+)
+
+
+__all__ = [
+    "ObservationSpaceKey",
+    "RewardObserver",
+    "MakespanReward",
+    "IdleTimeReward",
+    "SingleJobShopGraphEnv",
+    "RenderConfig",
+    "ObservationDict",
+    "add_padding",
+    "MultiJobShopGraphEnv",
+    "create_edge_type_dict",
+    "ResourceTaskGraphObservation",
+    "map_values",
+    "ResourceTaskGraphObservationDict",
+    "get_optimal_actions",
+]