job-shop-lib 0.5.1__py3-none-any.whl → 1.0.0a1__py3-none-any.whl

job_shop_lib/graphs/{node.py → _node.py}

@@ -1,7 +1,11 @@
 """Home of the `Node` class."""
 
-from job_shop_lib import Operation, JobShopLibError
-from job_shop_lib.graphs.constants import NodeType
+from job_shop_lib import Operation
+from job_shop_lib.exceptions import (
+    UninitializedAttributeError,
+    ValidationError,
+)
+from job_shop_lib.graphs._constants import NodeType
 
 
 class Node:
@@ -75,21 +79,21 @@ class Node:
                 node_type is NodeType.JOB.
 
         Raises:
-            JobShopLibError:
+            ValidationError:
                 If the node_type is OPERATION and operation is None.
-            JobShopLibError:
+            ValidationError:
                 If the node_type is MACHINE and machine_id is None.
-            JobShopLibError:
+            ValidationError:
                 If the node_type is JOB and job_id is None.
         """
         if node_type == NodeType.OPERATION and operation is None:
-            raise JobShopLibError("Operation node must have an operation.")
+            raise ValidationError("Operation node must have an operation.")
 
         if node_type == NodeType.MACHINE and machine_id is None:
-            raise JobShopLibError("Machine node must have a machine_id.")
+            raise ValidationError("Machine node must have a machine_id.")
 
         if node_type == NodeType.JOB and job_id is None:
-            raise JobShopLibError("Job node must have a job_id.")
+            raise ValidationError("Job node must have a job_id.")
 
         self.node_type = node_type
         self._node_id: int | None = None
@@ -102,7 +106,9 @@ class Node:
     def node_id(self) -> int:
         """Returns a unique identifier for the node."""
         if self._node_id is None:
-            raise JobShopLibError("Node has not been assigned an id.")
+            raise UninitializedAttributeError(
+                "Node has not been assigned an id."
+            )
         return self._node_id
 
     @node_id.setter
@@ -116,7 +122,7 @@ class Node:
         This property is mandatory for nodes of type `OPERATION`.
         """
         if self._operation is None:
-            raise JobShopLibError("Node has no operation.")
+            raise UninitializedAttributeError("Node has no operation.")
         return self._operation
 
     @property
@@ -126,7 +132,7 @@ class Node:
         This property is mandatory for nodes of type `MACHINE`.
         """
         if self._machine_id is None:
-            raise JobShopLibError("Node has no `machine_id`.")
+            raise UninitializedAttributeError("Node has no `machine_id`.")
         return self._machine_id
 
     @property
@@ -136,7 +142,7 @@ class Node:
         This property is mandatory for nodes of type `JOB`.
         """
         if self._job_id is None:
-            raise JobShopLibError("Node has no `job_id`.")
+            raise UninitializedAttributeError("Node has no `job_id`.")
         return self._job_id
 
     def __hash__(self) -> int:

job_shop_lib/graphs/graph_updaters/__init__.py

@@ -0,0 +1,13 @@
+"""Contains classes and functions for updating the graph representation of the
+job shop scheduling problem."""
+
+from ._graph_updater import GraphUpdater
+from ._utils import remove_completed_operations
+from ._residual_graph_updater import ResidualGraphUpdater
+
+
+__all__ = [
+    "GraphUpdater",
+    "remove_completed_operations",
+    "ResidualGraphUpdater",
+]

job_shop_lib/graphs/graph_updaters/_graph_updater.py

@@ -0,0 +1,59 @@
+"""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.
+    """
+
+    def __init__(
+        self,
+        dispatcher: Dispatcher,
+        job_shop_graph: JobShopGraph,
+        *,
+        subscribe: bool = True,
+    ):
+        """Initializes the class.
+
+        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.
+        """
+        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,154 @@
+"""Home of the `ResidualGraphUpdater` class."""
+
+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.
+    """
+
+    def __init__(
+        self,
+        dispatcher: Dispatcher,
+        job_shop_graph: JobShopGraph,
+        *,
+        subscribe: bool = True,
+        remove_completed_machine_nodes: bool = True,
+        remove_completed_job_nodes: bool = True,
+    ):
+        """Initializes the residual graph updater.
+
+        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.
+        """
+
+        self._is_completed_observer: None | 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=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 grah updater functions to update """
+
+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:
+        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,41 @@
+"""Package for reinforcement learning components."""
+
+from job_shop_lib.reinforcement_learning._types_and_constants import (
+    ObservationSpaceKey,
+    RenderConfig,
+    ObservationDict,
+    GanttChartWrapperConfig,
+    GifConfig,
+    VideoConfig,
+)
+
+from job_shop_lib.reinforcement_learning._reward_observers import (
+    RewardObserver,
+    MakespanReward,
+    IdleTimeReward,
+)
+
+from job_shop_lib.reinforcement_learning._utils import add_padding
+
+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,
+)
+
+
+__all__ = [
+    "ObservationSpaceKey",
+    "RewardObserver",
+    "MakespanReward",
+    "IdleTimeReward",
+    "GanttChartWrapperConfig",
+    "GifConfig",
+    "VideoConfig",
+    "SingleJobShopGraphEnv",
+    "RenderConfig",
+    "ObservationDict",
+    "add_padding",
+    "MultiJobShopGraphEnv",
+]