job-shop-lib 1.0.0b4__py3-none-any.whl → 1.0.1__py3-none-any.whl

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.4"
+__version__ = "1.0.1"
 
 __all__ = [
     "Operation",

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/_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/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/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/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/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/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/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/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/dispatching/feature_observers/_is_completed_observer.py

@@ -4,14 +4,10 @@ from typing import Optional, Union, List
 import numpy as np
 
 from job_shop_lib import ScheduledOperation
-from job_shop_lib.dispatching import (
-    Dispatcher,
-    DispatcherObserver,
-)
+from job_shop_lib.dispatching import Dispatcher
 from job_shop_lib.dispatching.feature_observers import (
     FeatureObserver,
     FeatureType,
-    RemainingOperationsObserver,
 )
 
 
@@ -40,15 +36,6 @@ class IsCompletedObserver(FeatureObserver):
             or manually updated.
     """
 
-    __slots__ = {
-        "remaining_ops_per_machine": (
-            "The number of unscheduled operations per machine."
-        ),
-        "remaining_ops_per_job": (
-            "The number of unscheduled operations per job."
-        ),
-    }
-
     def __init__(
         self,
         dispatcher: Dispatcher,
@@ -57,11 +44,16 @@ class IsCompletedObserver(FeatureObserver):
         subscribe: bool = True,
     ):
         feature_types = self._get_feature_types_list(feature_types)
-        self.remaining_ops_per_machine = np.zeros(
-            (dispatcher.instance.num_machines, 1), dtype=int
+        self._num_of_operations_per_machine = np.array(
+            [
+                len(operations_by_machine)
+                for operations_by_machine in (
+                    dispatcher.instance.operations_by_machine
+                )
+            ]
         )
-        self.remaining_ops_per_job = np.zeros(
-            (dispatcher.instance.num_jobs, 1), dtype=int
+        self._num_of_operations_per_job = np.array(
+            [len(job) for job in dispatcher.instance.jobs]
         )
         super().__init__(
             dispatcher,
@@ -70,60 +62,36 @@ class IsCompletedObserver(FeatureObserver):
         )
 
     def initialize_features(self):
-        def _has_same_features(observer: DispatcherObserver) -> bool:
-            if not isinstance(observer, RemainingOperationsObserver):
-                return False
-            return all(
-                feature_type in observer.features
-                for feature_type in remaining_ops_feature_types
-            )
-
-        self.set_features_to_zero()
-
-        remaining_ops_feature_types = [
-            feature_type
-            for feature_type in self.features.keys()
-            if feature_type != FeatureType.OPERATIONS
-        ]
-        remaining_ops_observer = self.dispatcher.create_or_get_observer(
-            RemainingOperationsObserver,
-            condition=_has_same_features,
-            feature_types=remaining_ops_feature_types,
-        )
-        if FeatureType.JOBS in self.features:
-            self.remaining_ops_per_job = remaining_ops_observer.features[
-                FeatureType.JOBS
-            ].copy()
-        if FeatureType.MACHINES in self.features:
-            self.remaining_ops_per_machine = remaining_ops_observer.features[
-                FeatureType.MACHINES
-            ].copy()
-
-    def reset(self):
-        self.initialize_features()
-
-    def update(self, scheduled_operation: ScheduledOperation):
         if FeatureType.OPERATIONS in self.features:
             completed_operations = [
-                op.operation_id
+                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:
-            self.remaining_ops_per_machine[
-                scheduled_operation.operation.machines, 0
-            ] -= 1
-            is_completed = (
-                self.remaining_ops_per_machine[
-                    scheduled_operation.operation.machines, 0
-                ]
-                == 0
+            num_completed_ops_per_machine = np.zeros(
+                len(self._num_of_operations_per_machine)
             )
-            self.features[FeatureType.MACHINES][
-                scheduled_operation.operation.machines, 0
-            ] = is_completed
+            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:
-            job_id = scheduled_operation.job_id
-            self.remaining_ops_per_job[job_id, 0] -= 1
-            is_completed = self.remaining_ops_per_job[job_id, 0] == 0
-            self.features[FeatureType.JOBS][job_id, 0] = is_completed
+            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/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/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/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/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/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

@@ -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/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.