job-shop-lib 1.0.0a5__py3-none-any.whl → 1.0.0b2__py3-none-any.whl

job_shop_lib/dispatching/_optimal_operations_observer.py

@@ -0,0 +1,115 @@
+"""Home of the `OptimalOperationsObserver` class."""
+
+from typing import List, Set, Dict
+from job_shop_lib.dispatching import DispatcherObserver, Dispatcher
+from job_shop_lib import Schedule, Operation, ScheduledOperation
+from job_shop_lib.exceptions import ValidationError
+
+
+class OptimalOperationsObserver(DispatcherObserver):
+    """Observer that identifies which available operations are optimal based on
+    a reference schedule.
+
+    This observer compares the available operations at each step with a
+    reference schedule to determine which operations would lead to the optimal
+    solution. It can be used for training purposes or to analyze decision
+    making in dispatching algorithms.
+
+    Attributes:
+        optimal_operations: Set of operations that are considered optimal
+            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.
+        reference_schedule: A complete schedule that represents the optimal
+            or reference solution.
+        subscribe: If True, automatically subscribes to the dispatcher.
+
+    Raises:
+        ValidationError: If the reference schedule is incomplete or if it
+            doesn't match the dispatcher's instance.
+    """
+
+    _is_singleton = False
+
+    def __init__(
+        self,
+        dispatcher: Dispatcher,
+        reference_schedule: Schedule,
+        *,
+        subscribe: bool = True,
+    ):
+        super().__init__(dispatcher, subscribe=subscribe)
+
+        if not reference_schedule.is_complete():
+            raise ValidationError("Reference schedule must be complete.")
+
+        if reference_schedule.instance != dispatcher.instance:
+            raise ValidationError(
+                "Reference schedule instance does not match dispatcher "
+                "instance."
+            )
+
+        self.reference_schedule = reference_schedule
+        self.optimal_available: Set[Operation] = set()
+        self._operation_to_scheduled: Dict[Operation, ScheduledOperation] = {}
+        self._machine_next_operation_index: List[int] = [0] * len(
+            reference_schedule.schedule
+        )
+
+        self._build_operation_mapping()
+        self._update_optimal_operations()
+
+    def _build_operation_mapping(self) -> None:
+        """Builds a mapping from operations to their scheduled versions in
+        the reference schedule."""
+        for machine_schedule in self.reference_schedule.schedule:
+            for scheduled_op in machine_schedule:
+                self._operation_to_scheduled[scheduled_op.operation] = (
+                    scheduled_op
+                )
+
+    def _update_optimal_operations(self) -> None:
+        """Updates the set of optimal operations based on current state.
+
+        An operation is considered optimal if it is the next unscheduled
+        operation in its machine's sequence according to the reference
+        schedule.
+        """
+        self.optimal_available.clear()
+        available_operations = self.dispatcher.available_operations()
+
+        if not available_operations:
+            return
+
+        for operation in available_operations:
+            scheduled_op = self._operation_to_scheduled[operation]
+            machine_index = scheduled_op.machine_id
+            next_index = self._machine_next_operation_index[machine_index]
+
+            if (
+                scheduled_op
+                == self.reference_schedule.schedule[machine_index][next_index]
+            ):
+                self.optimal_available.add(operation)
+
+    def update(self, scheduled_operation: ScheduledOperation) -> None:
+        """Updates the optimal operations after an operation is scheduled.
+
+        Args:
+            scheduled_operation: The operation that was just scheduled.
+        """
+        self._machine_next_operation_index[scheduled_operation.machine_id] += 1
+        self._update_optimal_operations()
+
+    def reset(self) -> None:
+        """Resets the observer to its initial state."""
+        self._machine_next_operation_index = [0] * len(
+            self.dispatcher.schedule.schedule
+        )
+        self.optimal_available.clear()
+        self._update_optimal_operations()

job_shop_lib/dispatching/_ready_operation_filters.py

@@ -4,6 +4,7 @@ This functions are used by the `Dispatcher` class to reduce the
 amount of available operations to choose from.
 """
 
+from typing import List, Set
 from collections.abc import Callable
 
 from job_shop_lib import Operation
@@ -11,13 +12,13 @@ from job_shop_lib.dispatching import Dispatcher
 
 
 ReadyOperationsFilter = Callable[
-    [Dispatcher, list[Operation]], list[Operation]
+    [Dispatcher, List[Operation]], List[Operation]
 ]
 
 
 def filter_non_idle_machines(
-    dispatcher: Dispatcher, operations: list[Operation]
-) -> list[Operation]:
+    dispatcher: Dispatcher, operations: List[Operation]
+) -> List[Operation]:
     """Filters out all the operations associated with non-idle machines.
 
     A machine is considered idle if there are no ongoing operations
@@ -40,7 +41,7 @@ def filter_non_idle_machines(
 
     # Filter operations to keep those that are associated with at least one
     # idle machine
-    filtered_operations: list[Operation] = []
+    filtered_operations: List[Operation] = []
     for operation in operations:
         if all(
             machine_id in non_idle_machines
@@ -54,7 +55,7 @@ def filter_non_idle_machines(
 
 def _get_non_idle_machines(
     dispatcher: Dispatcher, current_time: int
-) -> set[int]:
+) -> Set[int]:
     """Returns the set of machine ids that are currently busy (i.e., have at
     least one uncompleted operation)."""
 
@@ -70,8 +71,8 @@ def _get_non_idle_machines(
 
 
 def filter_non_immediate_operations(
-    dispatcher: Dispatcher, operations: list[Operation]
-) -> list[Operation]:
+    dispatcher: Dispatcher, operations: List[Operation]
+) -> List[Operation]:
     """Filters out all the operations that can't start immediately.
 
     An operation can start immediately if its earliest start time is the
@@ -86,7 +87,7 @@ def filter_non_immediate_operations(
     """
 
     min_start_time = dispatcher.min_start_time(operations)
-    immediate_operations: list[Operation] = []
+    immediate_operations: List[Operation] = []
     for operation in operations:
         start_time = dispatcher.earliest_start_time(operation)
         if start_time == min_start_time:
@@ -96,8 +97,8 @@ def filter_non_immediate_operations(
 
 
 def filter_dominated_operations(
-    dispatcher: Dispatcher, operations: list[Operation]
-) -> list[Operation]:
+    dispatcher: Dispatcher, operations: List[Operation]
+) -> List[Operation]:
     """Filters out all the operations that are dominated.
     An operation is dominated if there is another operation that ends before
     it starts on the same machine.
@@ -105,7 +106,7 @@ def filter_dominated_operations(
 
     min_machine_end_times = _get_min_machine_end_times(dispatcher, operations)
 
-    non_dominated_operations: list[Operation] = []
+    non_dominated_operations: List[Operation] = []
     for operation in operations:
         # One benchmark instance has an operation with duration 0
         if operation.duration == 0:
@@ -121,13 +122,13 @@ def filter_dominated_operations(
 
 
 def filter_non_immediate_machines(
-    dispatcher: Dispatcher, operations: list[Operation]
-) -> list[Operation]:
+    dispatcher: Dispatcher, operations: List[Operation]
+) -> List[Operation]:
     """Filters out all the operations associated with machines which earliest
     operation is not the current time."""
 
     is_immediate_machine = _get_immediate_machines(dispatcher, operations)
-    non_dominated_operations: list[Operation] = []
+    non_dominated_operations: List[Operation] = []
     for operation in operations:
         if any(
             is_immediate_machine[machine_id]
@@ -139,8 +140,8 @@ def filter_non_immediate_machines(
 
 
 def _get_min_machine_end_times(
-    dispatcher: Dispatcher, available_operations: list[Operation]
-) -> list[int | float]:
+    dispatcher: Dispatcher, available_operations: List[Operation]
+) -> List[float]:
     end_times_per_machine = [float("inf")] * dispatcher.instance.num_machines
     for op in available_operations:
         for machine_id in op.machines:
@@ -152,8 +153,8 @@ def _get_min_machine_end_times(
 
 
 def _get_immediate_machines(
-    self: Dispatcher, available_operations: list[Operation]
-) -> list[bool]:
+    self: 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

job_shop_lib/dispatching/_unscheduled_operations_observer.py

@@ -3,7 +3,7 @@
 import collections
 from collections.abc import Iterable
 import itertools
-from typing import Deque
+from typing import Deque, List
 
 from job_shop_lib import Operation, ScheduledOperation
 from job_shop_lib.dispatching import DispatcherObserver, Dispatcher
@@ -19,7 +19,7 @@ class UnscheduledOperationsObserver(DispatcherObserver):
 
     def __init__(self, dispatcher: Dispatcher, *, subscribe: bool = True):
         super().__init__(dispatcher, subscribe=subscribe)
-        self.unscheduled_operations_per_job: list[Deque[Operation]] = []
+        self.unscheduled_operations_per_job: List[Deque[Operation]] = []
         self.reset()
         # In case the dispatcher has already scheduled some operations,
         # we need to remove them.
@@ -51,7 +51,8 @@ class UnscheduledOperationsObserver(DispatcherObserver):
         unscheduled operations.
 
         Args:
-            scheduled_operation: The operation that has been scheduled.
+            scheduled_operation:
+                The operation that has been scheduled.
         """
         job_id = scheduled_operation.operation.job_id
         job_deque = self.unscheduled_operations_per_job[job_id]

job_shop_lib/dispatching/feature_observers/_composite_feature_observer.py

@@ -2,12 +2,11 @@
 
 from collections import defaultdict
 from collections.abc import Sequence
-
+from typing import List, Dict, Union, Optional
 # 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.10.
+# python >=3.8
 from typing_extensions import Self
-
 import numpy as np
 from numpy.typing import NDArray
 import pandas as pd
@@ -77,8 +76,8 @@ class CompositeFeatureObserver(FeatureObserver):
         dispatcher: Dispatcher,
         *,
         subscribe: bool = True,
-        feature_types: list[FeatureType] | FeatureType | None = None,
-        feature_observers: list[FeatureObserver] | None = None,
+        feature_types: Optional[Union[List[FeatureType], FeatureType]] = None,
+        feature_observers: Optional[List[FeatureObserver]] = None,
     ):
         if feature_observers is None:
             feature_observers = [
@@ -97,7 +96,7 @@ class CompositeFeatureObserver(FeatureObserver):
                     f"Composite feature types: {feature_types}"
                 )
         self.feature_observers = feature_observers
-        self.column_names: dict[FeatureType, list[str]] = defaultdict(list)
+        self.column_names: Dict[FeatureType, List[str]] = defaultdict(list)
         super().__init__(dispatcher, subscribe=subscribe)
         self._set_column_names()
 
@@ -129,7 +128,7 @@ class CompositeFeatureObserver(FeatureObserver):
         return composite_observer
 
     @property
-    def features_as_dataframe(self) -> dict[FeatureType, pd.DataFrame]:
+    def features_as_dataframe(self) -> Dict[FeatureType, pd.DataFrame]:
         """Returns the features as a dictionary of `pd.DataFrame` instances."""
         return {
             feature_type: pd.DataFrame(
@@ -139,7 +138,7 @@ class CompositeFeatureObserver(FeatureObserver):
         }
 
     def initialize_features(self):
-        features: dict[FeatureType, list[NDArray[np.float32]]] = defaultdict(
+        features: Dict[FeatureType, List[NDArray[np.float32]]] = defaultdict(
             list
         )
         for observer in self.feature_observers:

job_shop_lib/dispatching/feature_observers/_earliest_start_time_observer.py

@@ -1,5 +1,7 @@
 """Home of the `EarliestStartTimeObserver` class."""
 
+from typing import List, Optional, Union
+
 import numpy as np
 from numpy.typing import NDArray
 
@@ -75,7 +77,7 @@ class EarliestStartTimeObserver(FeatureObserver):
         dispatcher: Dispatcher,
         *,
         subscribe: bool = True,
-        feature_types: list[FeatureType] | FeatureType | None = None,
+        feature_types: Optional[Union[List[FeatureType], FeatureType]] = None,
     ):
 
         # Earliest start times initialization

job_shop_lib/dispatching/feature_observers/_factory.py

@@ -1,6 +1,7 @@
 """Contains factory functions for creating :class:`FeatureObserver`s."""
 
 from enum import Enum
+from typing import Union, Type
 
 from job_shop_lib.dispatching import DispatcherObserverConfig
 from job_shop_lib.dispatching.feature_observers import (
@@ -36,22 +37,20 @@ class FeatureObserverType(str, Enum):
 
 
 # FeatureObserverConfig = DispatcherObserverConfig[
-#     type[FeatureObserver] | FeatureObserverType | str
+#     Type[FeatureObserver] | FeatureObserverType | str
 # ]
-FeatureObserverConfig = (
-    DispatcherObserverConfig[type[FeatureObserver]]
-    | DispatcherObserverConfig[FeatureObserverType]
-    | DispatcherObserverConfig[str]
-)
+FeatureObserverConfig = DispatcherObserverConfig[
+    Union[Type[FeatureObserver], FeatureObserverType, str]
+]
 
 
 def feature_observer_factory(
-    feature_observer_type: (
-        str
-        | FeatureObserverType
-        | type[FeatureObserver]
-        | FeatureObserverConfig
-    ),
+    feature_observer_type: Union[
+        str,
+        FeatureObserverType,
+        Type[FeatureObserver],
+        FeatureObserverConfig
+    ],
     **kwargs,
 ) -> FeatureObserver:
     """Creates and returns a :class:`FeatureObserver` based on the specified
@@ -73,12 +72,12 @@ def feature_observer_factory(
             **feature_observer_type.kwargs,
             **kwargs,
         )
-    # if the instance is of type type[FeatureObserver] we can just
+    # if the instance is of type Type[FeatureObserver] we can just
     # call the object constructor with the keyword arguments
     if isinstance(feature_observer_type, type):
         return feature_observer_type(**kwargs)
 
-    mapping: dict[FeatureObserverType, type[FeatureObserver]] = {
+    mapping: dict[FeatureObserverType, Type[FeatureObserver]] = {
         FeatureObserverType.IS_READY: IsReadyObserver,
         FeatureObserverType.EARLIEST_START_TIME: EarliestStartTimeObserver,
         FeatureObserverType.DURATION: DurationObserver,

job_shop_lib/dispatching/feature_observers/_feature_observer.py

@@ -1,6 +1,7 @@
 """Home of the `FeatureObserver` class and `FeatureType` enum."""
 
 import enum
+from typing import Optional, Union, Dict, List, Tuple
 
 import numpy as np
 
@@ -64,7 +65,7 @@ class FeatureObserver(DispatcherObserver):
     """
 
     _is_singleton = False
-    _feature_sizes: dict[FeatureType, int] | int = 1
+    _feature_sizes: Union[Dict[FeatureType, int], int] = 1
     _supported_feature_types = list(FeatureType)
 
     __slots__ = {
@@ -84,7 +85,7 @@ class FeatureObserver(DispatcherObserver):
         dispatcher: Dispatcher,
         *,
         subscribe: bool = True,
-        feature_types: list[FeatureType] | FeatureType | None = None,
+        feature_types: Optional[Union[List[FeatureType], FeatureType]] = None,
     ):
         feature_types = self._get_feature_types_list(feature_types)
         if isinstance(self._feature_sizes, int):
@@ -116,7 +117,7 @@ class FeatureObserver(DispatcherObserver):
         self.initialize_features()
 
     @property
-    def feature_sizes(self) -> dict[FeatureType, int]:
+    def feature_sizes(self) -> Dict[FeatureType, int]:
         """Returns the size of the features.
 
         The size of the features is the number of values being observed for
@@ -134,12 +135,12 @@ class FeatureObserver(DispatcherObserver):
         return self._feature_sizes
 
     @property
-    def supported_feature_types(self) -> list[FeatureType]:
+    def supported_feature_types(self) -> List[FeatureType]:
         """Returns the supported feature types."""
         return self._supported_feature_types
 
     @property
-    def feature_dimensions(self) -> dict[FeatureType, tuple[int, int]]:
+    def feature_dimensions(self) -> Dict[FeatureType, Tuple[int, int]]:
         """A dictionary containing the shape of each :class:`FeatureType`."""
         feature_dimensions = {}
         for feature_type, array in self.features.items():
@@ -170,7 +171,7 @@ class FeatureObserver(DispatcherObserver):
         self.initialize_features()
 
     def set_features_to_zero(
-        self, exclude: FeatureType | list[FeatureType] | None = None
+        self, exclude: Optional[Union[FeatureType, List[FeatureType]]] = None
     ):
         """Sets all features to zero except for the ones specified in
         ``exclude``.
@@ -196,8 +197,8 @@ class FeatureObserver(DispatcherObserver):
 
     def _get_feature_types_list(
         self,
-        feature_types: list[FeatureType] | FeatureType | None,
-    ) -> list[FeatureType]:
+        feature_types: Optional[Union[List[FeatureType], FeatureType]],
+    ) -> List[FeatureType]:
         """Returns a list of feature types.
 
         Args:

job_shop_lib/dispatching/feature_observers/_is_completed_observer.py

@@ -1,5 +1,6 @@
 """Home of the `IsCompletedObserver` class."""
 
+from typing import Optional, Union, List
 import numpy as np
 
 from job_shop_lib import ScheduledOperation
@@ -52,7 +53,7 @@ class IsCompletedObserver(FeatureObserver):
         self,
         dispatcher: Dispatcher,
         *,
-        feature_types: list[FeatureType] | FeatureType | None = None,
+        feature_types: Optional[Union[List[FeatureType], FeatureType]] = None,
         subscribe: bool = True,
     ):
         feature_types = self._get_feature_types_list(feature_types)

job_shop_lib/dispatching/feature_observers/_is_ready_observer.py

@@ -1,5 +1,7 @@
 """Home of the `IsReadyObserver` class."""
 
+from typing import List
+
 from job_shop_lib.dispatching.feature_observers import (
     FeatureObserver,
     FeatureType,
@@ -16,7 +18,7 @@ class IsReadyObserver(FeatureObserver):
             feature_ids = self._get_ready_feature_ids(feature_type)
             feature[feature_ids, 0] = 1.0
 
-    def _get_ready_feature_ids(self, feature_type: FeatureType) -> list[int]:
+    def _get_ready_feature_ids(self, feature_type: FeatureType) -> List[int]:
         if feature_type == FeatureType.OPERATIONS:
             return self._get_ready_operations()
         if feature_type == FeatureType.MACHINES:
@@ -28,6 +30,6 @@ class IsReadyObserver(FeatureObserver):
     def reset(self):
         self.initialize_features()
 
-    def _get_ready_operations(self) -> list[int]:
+    def _get_ready_operations(self) -> List[int]:
         available_operations = self.dispatcher.available_operations()
         return [operation.operation_id for operation in available_operations]

job_shop_lib/dispatching/rules/__init__.py

@@ -1,4 +1,40 @@
-"""Contains the dispatching rules for the job shop scheduling problem."""
+"""Contains the dispatching rules for the job shop scheduling problem.
+
+Main objects:
+
+.. autosummary::
+
+    DispatchingRuleSolver
+    dispatching_rule_factory
+    DispatchingRuleType
+    MachineChooserType
+    dispatching_rule_factory
+    machine_chooser_factory
+
+Dispatching rules:
+
+.. autosummary::
+
+    shortest_processing_time_rule
+    first_come_first_served_rule
+    most_work_remaining_rule
+    most_operations_remaining_rule
+    random_operation_rule
+    score_based_rule
+    score_based_rule_with_tie_breaker
+    observer_based_most_work_remaining_rule
+
+Dispatching rule scorers:
+
+.. autosummary::
+
+    shortest_processing_time_score
+    first_come_first_served_score
+    MostWorkRemainingScorer
+    most_operations_remaining_score
+    random_score
+
+"""
 
 from ._dispatching_rules_functions import (
     shortest_processing_time_rule,

job_shop_lib/dispatching/rules/_dispatching_rule_factory.py

@@ -5,6 +5,8 @@ The factory functions create and return the appropriate functions based on the
 specified names or enums.
 """
 
+from typing import Dict, Union
+
 from enum import Enum
 from collections.abc import Callable
 
@@ -31,7 +33,7 @@ class DispatchingRuleType(str, Enum):
 
 
 def dispatching_rule_factory(
-    dispatching_rule: str | DispatchingRuleType,
+    dispatching_rule: Union[str, DispatchingRuleType,]
 ) -> Callable[[Dispatcher], Operation]:
     """Creates and returns a dispatching rule function based on the specified
     dispatching rule name.
@@ -55,7 +57,7 @@ def dispatching_rule_factory(
             If the dispatching_rule argument is not recognized or it is
             not supported.
     """
-    dispatching_rules: dict[
+    dispatching_rules: Dict[
         DispatchingRuleType,
         Callable[[Dispatcher], Operation],
     ] = {

job_shop_lib/dispatching/rules/_dispatching_rule_solver.py

@@ -1,5 +1,6 @@
 """Home of the `DispatchingRuleSolver` class."""
 
+from typing import Optional, Union
 from collections.abc import Callable, Iterable
 
 from job_shop_lib import JobShopInstance, Schedule, Operation, BaseSolver
@@ -29,14 +30,14 @@ class DispatchingRuleSolver(BaseSolver):
             Used to choose the machine where the operation will be dispatched
             to. It is only used if the operation can be dispatched to multiple
             machines.
-        pruning_function:
-            The pruning function to use. It is used to initialize the
+        ready_operations_filter:
+            The ready operations filter to use. It is used to initialize the
             dispatcher object internally when calling the solve method.
 
     Args:
         dispatching_rule:
             The dispatching rule to use. It can be a string with the name
-            of the dispatching rule, a class`DispatchingRuleType` enum member,
+            of the dispatching rule, a :class:`DispatchingRuleType` member,
             or a callable that takes a dispatcher and returns the operation to
             be dispatched next.
         machine_chooser:
@@ -65,21 +66,26 @@ class DispatchingRuleSolver(BaseSolver):
 
     def __init__(
         self,
-        dispatching_rule: (
-            str | Callable[[Dispatcher], Operation]
-        ) = DispatchingRuleType.MOST_WORK_REMAINING,
-        machine_chooser: (
-            str | Callable[[Dispatcher, Operation], int]
-        ) = MachineChooserType.FIRST,
-        ready_operations_filter: (
-            Iterable[ReadyOperationsFilter | str | ReadyOperationsFilterType]
-            | str
-            | ReadyOperationsFilterType
-            | ReadyOperationsFilter
-            | None
-        ) = (
+        dispatching_rule: Union[
+            str, Callable[[Dispatcher], Operation]
+        ] = DispatchingRuleType.MOST_WORK_REMAINING,
+        machine_chooser: Union[
+            str, Callable[[Dispatcher, Operation], int]
+        ] = MachineChooserType.FIRST,
+        ready_operations_filter: Optional[
+            Union[
+                Iterable[
+                    Union[
+                        ReadyOperationsFilter, str, ReadyOperationsFilterType
+                    ]
+                ],
+                str,
+                ReadyOperationsFilterType,
+                ReadyOperationsFilter,
+            ]
+        ] = (
             ReadyOperationsFilterType.DOMINATED_OPERATIONS,
-            ReadyOperationsFilterType.NON_IDLE_MACHINES,
+            ReadyOperationsFilterType.NON_IMMEDIATE_OPERATIONS,
         ),
     ):
         if isinstance(dispatching_rule, str):
@@ -100,10 +106,34 @@ class DispatchingRuleSolver(BaseSolver):
         self.ready_operations_filter = ready_operations_filter
 
     def solve(
-        self, instance: JobShopInstance, dispatcher: Dispatcher | None = None
+        self,
+        instance: JobShopInstance,
+        dispatcher: Optional[Dispatcher] = None,
     ) -> Schedule:
-        """Returns a schedule for the given job shop instance using the
-        dispatching rule algorithm."""
+        """Solves the instance using the dispatching rule and machine chooser
+        algorithms.
+
+        Args:
+            instance:
+                The job shop instance to be solved.
+            dispatcher:
+                The dispatcher object that will be used to dispatch the
+                operations. If not provided, a new dispatcher will be created
+                using the ready operations filter provided in the constructor.
+
+        Returns:
+            The schedule obtained after solving the instance.
+
+        .. tip::
+            Another way to use the solver is by calling it as a function. This
+            will call the ``solve`` method internally and will add metadata to
+            the schedule. For example:
+
+            .. code-block:: python
+
+                solver = DispatchingRuleSolver()
+                schedule = solver(instance)
+        """
         if dispatcher is None:
             dispatcher = Dispatcher(
                 instance, ready_operations_filter=self.ready_operations_filter