job-shop-lib 1.0.2__py3-none-any.whl → 1.0.3__py3-none-any.whl

job_shop_lib/dispatching/_ready_operation_filters.py

@@ -4,7 +4,6 @@ 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
@@ -12,13 +11,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
@@ -41,7 +40,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
@@ -55,7 +54,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)."""
 
@@ -71,8 +70,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
@@ -87,7 +86,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:
@@ -97,8 +96,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.
@@ -106,7 +105,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:
@@ -122,13 +121,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]
@@ -140,8 +139,8 @@ def filter_non_immediate_machines(
 
 
 def _get_min_machine_end_times(
-    dispatcher: Dispatcher, available_operations: List[Operation]
-) -> List[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:
@@ -153,8 +152,8 @@ def _get_min_machine_end_times(
 
 
 def _get_immediate_machines(
-    dispatcher: Dispatcher, available_operations: List[Operation]
-) -> List[bool]:
+    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] * dispatcher.instance.num_machines

job_shop_lib/dispatching/_unscheduled_operations_observer.py

@@ -3,7 +3,6 @@
 import collections
 from collections.abc import Iterable
 import itertools
-from typing import Deque, List
 
 from job_shop_lib import Operation, ScheduledOperation
 from job_shop_lib.dispatching import DispatcherObserver, Dispatcher
@@ -19,7 +18,9 @@ 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[
+            collections.deque[Operation]
+        ] = []
         self.reset()
         # In case the dispatcher has already scheduled some operations,
         # we need to remove them.

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, 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.10
@@ -77,8 +77,8 @@ class CompositeFeatureObserver(FeatureObserver):
         dispatcher: Dispatcher,
         *,
         subscribe: bool = True,
-        feature_types: Optional[Union[List[FeatureType], FeatureType]] = None,
-        feature_observers: Optional[List[FeatureObserver]] = None,
+        feature_types: list[FeatureType] | FeatureType | None = None,
+        feature_observers: list[FeatureObserver] | None = None,
     ):
         if feature_observers is None:
             feature_observers = [
@@ -97,7 +97,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()
 
@@ -106,12 +106,10 @@ class CompositeFeatureObserver(FeatureObserver):
         cls,
         dispatcher: Dispatcher,
         feature_observer_configs: Sequence[
-            Union[
-                str,
-                FeatureObserverType,
-                Type[FeatureObserver],
-                FeatureObserverConfig,
-            ],
+            str
+            | FeatureObserverType
+            | type[FeatureObserver]
+            | FeatureObserverConfig
         ],
         subscribe: bool = True,
     ) -> Self:
@@ -136,7 +134,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(
@@ -146,7 +144,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,7 +1,5 @@
 """Home of the `EarliestStartTimeObserver` class."""
 
-from typing import List, Optional, Union
-
 import numpy as np
 from numpy.typing import NDArray
 
@@ -77,7 +75,7 @@ class EarliestStartTimeObserver(FeatureObserver):
         dispatcher: Dispatcher,
         *,
         subscribe: bool = True,
-        feature_types: Optional[Union[List[FeatureType], FeatureType]] = None,
+        feature_types: list[FeatureType] | FeatureType | None = None,
     ):
 
         # Earliest start times initialization

job_shop_lib/dispatching/feature_observers/_factory.py

@@ -1,7 +1,6 @@
 """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 (
@@ -37,25 +36,25 @@ class FeatureObserverType(str, Enum):
 
 
 # FeatureObserverConfig = DispatcherObserverConfig[
-#     Type[FeatureObserver] | FeatureObserverType | str
+#     type[FeatureObserver] | FeatureObserverType | str
 # ]
 # FeatureObserverConfig = DispatcherObserverConfig[
-#     Union[Type[FeatureObserver], FeatureObserverType, str]
+#     Union[type[FeatureObserver], FeatureObserverType, str]
 # ]
 FeatureObserverConfig = (
-    DispatcherObserverConfig[Type[FeatureObserver]]
+    DispatcherObserverConfig[type[FeatureObserver]]
     | DispatcherObserverConfig[FeatureObserverType]
     | DispatcherObserverConfig[str]
 )
 
 
 def feature_observer_factory(
-    feature_observer_type: Union[
-        str,
-        FeatureObserverType,
-        Type[FeatureObserver],
-        FeatureObserverConfig
-    ],
+    feature_observer_type: (
+        str
+        | FeatureObserverType
+        | type[FeatureObserver]
+        | FeatureObserverConfig
+    ),
     **kwargs,
 ) -> FeatureObserver:
     """Creates and returns a :class:`FeatureObserver` based on the specified
@@ -77,12 +76,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,7 +1,6 @@
 """Home of the `FeatureObserver` class and `FeatureType` enum."""
 
 import enum
-from typing import Optional, Union, Dict, List, Tuple
 
 import numpy as np
 
@@ -65,7 +64,7 @@ class FeatureObserver(DispatcherObserver):
     """
 
     _is_singleton = False
-    _feature_sizes: Union[Dict[FeatureType, int], int] = 1
+    _feature_sizes: dict[FeatureType, int] | int = 1
     _supported_feature_types = list(FeatureType)
 
     __slots__ = {
@@ -85,7 +84,7 @@ class FeatureObserver(DispatcherObserver):
         dispatcher: Dispatcher,
         *,
         subscribe: bool = True,
-        feature_types: Optional[Union[List[FeatureType], FeatureType]] = None,
+        feature_types: list[FeatureType] | FeatureType | None = None,
     ):
         feature_types = self._get_feature_types_list(feature_types)
         if isinstance(self._feature_sizes, int):
@@ -117,7 +116,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
@@ -135,12 +134,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():
@@ -171,7 +170,7 @@ class FeatureObserver(DispatcherObserver):
         self.initialize_features()
 
     def set_features_to_zero(
-        self, exclude: Optional[Union[FeatureType, List[FeatureType]]] = None
+        self, exclude: FeatureType | list[FeatureType] | None = None
     ):
         """Sets all features to zero except for the ones specified in
         ``exclude``.
@@ -197,8 +196,8 @@ class FeatureObserver(DispatcherObserver):
 
     def _get_feature_types_list(
         self,
-        feature_types: Optional[Union[List[FeatureType], FeatureType]],
-    ) -> List[FeatureType]:
+        feature_types: list[FeatureType] | FeatureType | None,
+    ) -> list[FeatureType]:
         """Returns a list of feature types.
 
         Args:

job_shop_lib/dispatching/feature_observers/_is_completed_observer.py

@@ -1,6 +1,5 @@
 """Home of the `IsCompletedObserver` class."""
 
-from typing import Optional, Union, List
 import numpy as np
 
 from job_shop_lib import ScheduledOperation
@@ -40,7 +39,7 @@ class IsCompletedObserver(FeatureObserver):
         self,
         dispatcher: Dispatcher,
         *,
-        feature_types: Optional[Union[List[FeatureType], FeatureType]] = None,
+        feature_types: list[FeatureType] | FeatureType | None = None,
         subscribe: bool = True,
     ):
         feature_types = self._get_feature_types_list(feature_types)
@@ -86,8 +85,7 @@ class IsCompletedObserver(FeatureObserver):
             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
+                num_completed_ops_per_job == self._num_of_operations_per_job
             ).astype(np.float32)
 
     def reset(self):

job_shop_lib/dispatching/feature_observers/_is_ready_observer.py

@@ -1,7 +1,5 @@
 """Home of the `IsReadyObserver` class."""
 
-from typing import List
-
 from job_shop_lib.dispatching.feature_observers import (
     FeatureObserver,
     FeatureType,
@@ -18,7 +16,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:
@@ -30,6 +28,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/_dispatching_rule_factory.py

@@ -5,8 +5,6 @@ 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
 
@@ -33,7 +31,7 @@ class DispatchingRuleType(str, Enum):
 
 
 def dispatching_rule_factory(
-    dispatching_rule: Union[str, DispatchingRuleType],
+    dispatching_rule: str | DispatchingRuleType,
 ) -> Callable[[Dispatcher], Operation]:
     """Creates and returns a dispatching rule function based on the specified
     dispatching rule name.
@@ -57,7 +55,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,6 +1,5 @@
 """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
@@ -66,24 +65,19 @@ class DispatchingRuleSolver(BaseSolver):
 
     def __init__(
         self,
-        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,
-            ]
-        ] = (
+        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
+        ) = (
             ReadyOperationsFilterType.DOMINATED_OPERATIONS,
             ReadyOperationsFilterType.NON_IMMEDIATE_OPERATIONS,
         ),
@@ -108,7 +102,7 @@ class DispatchingRuleSolver(BaseSolver):
     def solve(
         self,
         instance: JobShopInstance,
-        dispatcher: Optional[Dispatcher] = None,
+        dispatcher: Dispatcher | None = None,
     ) -> Schedule:
         """Solves the instance using the dispatching rule and machine chooser
         algorithms.
@@ -159,6 +153,7 @@ class DispatchingRuleSolver(BaseSolver):
 if __name__ == "__main__":
     import time
     import cProfile
+
     # import pstats
     # from io import StringIO
     from job_shop_lib.benchmarking import (

job_shop_lib/dispatching/rules/_dispatching_rules_functions.py

@@ -6,7 +6,6 @@ which operations are selected for execution based on certain criteria such as
 shortest processing time, first come first served, etc.
 """
 
-from typing import List, Optional
 from collections.abc import Callable, Sequence
 import random
 
@@ -65,7 +64,7 @@ def random_operation_rule(dispatcher: Dispatcher) -> Operation:
 
 
 def score_based_rule(
-    score_function: Callable[[Dispatcher], Sequence[float]]
+    score_function: Callable[[Dispatcher], Sequence[float]],
 ) -> Callable[[Dispatcher], Operation]:
     """Creates a dispatching rule based on a scoring function.
 
@@ -89,7 +88,7 @@ def score_based_rule(
 
 
 def score_based_rule_with_tie_breaker(
-    score_functions: List[Callable[[Dispatcher], Sequence[int]]],
+    score_functions: list[Callable[[Dispatcher], Sequence[int]]],
 ) -> Callable[[Dispatcher], Operation]:
     """Creates a dispatching rule based on multiple scoring functions.
 
@@ -123,7 +122,7 @@ def score_based_rule_with_tie_breaker(
 # -----------------
 
 
-def shortest_processing_time_score(dispatcher: Dispatcher) -> List[int]:
+def shortest_processing_time_score(dispatcher: Dispatcher) -> list[int]:
     """Scores each job based on the duration of the next operation."""
     num_jobs = dispatcher.instance.num_jobs
     scores = [0] * num_jobs
@@ -132,7 +131,7 @@ def shortest_processing_time_score(dispatcher: Dispatcher) -> List[int]:
     return scores
 
 
-def first_come_first_served_score(dispatcher: Dispatcher) -> List[int]:
+def first_come_first_served_score(dispatcher: Dispatcher) -> list[int]:
     """Scores each job based on the position of the next operation."""
     num_jobs = dispatcher.instance.num_jobs
     scores = [0] * num_jobs
@@ -154,9 +153,9 @@ class MostWorkRemainingScorer:  # pylint: disable=too-few-public-methods
     """
 
     def __init__(self) -> None:
-        self._duration_observer: Optional[DurationObserver] = None
-        self._is_ready_observer: Optional[IsReadyObserver] = None
-        self._current_dispatcher: Optional[Dispatcher] = None
+        self._duration_observer: DurationObserver | None = None
+        self._is_ready_observer: IsReadyObserver | None = None
+        self._current_dispatcher: Dispatcher | None = None
 
     def __call__(self, dispatcher: Dispatcher) -> Sequence[int]:
         """Scores each job based on the remaining work in the job."""
@@ -198,7 +197,7 @@ observer_based_most_work_remaining_rule = score_based_rule(
 )
 
 
-def most_operations_remaining_score(dispatcher: Dispatcher) -> List[int]:
+def most_operations_remaining_score(dispatcher: Dispatcher) -> list[int]:
     """Scores each job based on the remaining operations in the job."""
     num_jobs = dispatcher.instance.num_jobs
     scores = [0] * num_jobs
@@ -207,7 +206,7 @@ def most_operations_remaining_score(dispatcher: Dispatcher) -> List[int]:
     return scores
 
 
-def random_score(dispatcher: Dispatcher) -> List[int]:
+def random_score(dispatcher: Dispatcher) -> list[int]:
     """Scores each job randomly."""
     return [
         random.randint(0, 100) for _ in range(dispatcher.instance.num_jobs)

job_shop_lib/dispatching/rules/_machine_chooser_factory.py

@@ -5,7 +5,6 @@ The factory functions create and return the appropriate functions based on the
 specified names or enums.
 """
 
-from typing import Union, Dict
 from enum import Enum
 from collections.abc import Callable
 import random
@@ -26,7 +25,7 @@ MachineChooser = Callable[[Dispatcher, Operation], int]
 
 
 def machine_chooser_factory(
-    machine_chooser: Union[str, MachineChooser],
+    machine_chooser: str | MachineChooser,
 ) -> MachineChooser:
     """Creates and returns a machine chooser function based on the specified
     machine chooser strategy name.
@@ -51,7 +50,7 @@ def machine_chooser_factory(
             If the ``machine_chooser`` argument is not recognized or
             is not supported.
     """
-    machine_choosers: Dict[str, Callable[[Dispatcher, Operation], int]] = {
+    machine_choosers: dict[str, Callable[[Dispatcher, Operation], int]] = {
         MachineChooserType.FIRST: lambda _, operation: operation.machines[0],
         MachineChooserType.RANDOM: lambda _, operation: random.choice(
             operation.machines

job_shop_lib/dispatching/rules/_utils.py

@@ -1,6 +1,5 @@
 """Utility functions."""
 
-from typing import Union, List
 import time
 from collections.abc import Callable
 import pandas as pd
@@ -11,12 +10,12 @@ from job_shop_lib.dispatching import Dispatcher
 
 
 def benchmark_dispatching_rules(
-    dispatching_rules: Union[
-        List[Union[str, Callable[[Dispatcher], Operation]]],
-        List[str],
-        List[Callable[[Dispatcher], Operation]]
-    ],
-    instances: List[JobShopInstance],
+    dispatching_rules: (
+        list[str | Callable[[Dispatcher], Operation]]
+        | list[str]
+        | list[Callable[[Dispatcher], Operation]]
+    ),
+    instances: list[JobShopInstance],
 ) -> pd.DataFrame:
     """Benchmark multiple dispatching rules on multiple JobShopInstances.
 
@@ -112,7 +111,7 @@ if __name__ == "__main__":
     instances_ = [load_benchmark_instance(f"ta{i:02d}") for i in range(1, 3)]
 
     # Define rules
-    rules_: List[str | Callable[[Dispatcher], Operation]] = [
+    rules_: list[str | Callable[[Dispatcher], Operation]] = [
         "most_work_remaining",
         "shortest_processing_time",
         most_work_remaining_rule,