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

job_shop_lib/dispatching/feature_observers/{feature_observer.py → _feature_observer.py}

@@ -3,7 +3,9 @@
 import enum
 
 import numpy as np
+
 from job_shop_lib import ScheduledOperation
+from job_shop_lib.exceptions import ValidationError
 from job_shop_lib.dispatching import Dispatcher, DispatcherObserver
 
 
@@ -16,22 +18,40 @@ class FeatureType(str, enum.Enum):
 
 
 class FeatureObserver(DispatcherObserver):
-    """Base class for feature observers."""
+    """Base class for feature observers.
+
+    Feature observers are not singleton by default. This means that more than
+    one instance of the same feature observer type can be subscribed to the
+    dispatcher. This is useful when the first subscriber only observes a subset
+    of the features, and the second subscriber observes a different subset of
+    them. For example, the first subscriber could observe only the
+    operation-related features, while the second subscriber could observe the
+    jobs.
+    """
+
+    _is_singleton = False
+    _feature_size: dict[FeatureType, int] | int = 1
+    _supported_feature_types = list(FeatureType)
+
+    __slots__ = (
+        "features",
+        "feature_dimensions",
+    )
 
     def __init__(
         self,
         dispatcher: Dispatcher,
-        feature_types: list[FeatureType] | FeatureType | None = None,
-        feature_size: dict[FeatureType, int] | int = 1,
-        is_singleton: bool = True,
+        *,
         subscribe: bool = True,
+        feature_types: list[FeatureType] | FeatureType | None = None,
     ):
-        feature_types = self.get_feature_types_list(feature_types)
-        if isinstance(feature_size, int):
+        feature_types = self._get_feature_types_list(feature_types)
+        if isinstance(self._feature_size, int):
             feature_size = {
-                feature_type: feature_size for feature_type in feature_types
+                feature_type: self._feature_size
+                for feature_type in feature_types
             }
-        super().__init__(dispatcher, is_singleton, subscribe)
+        super().__init__(dispatcher, subscribe=subscribe)
 
         number_of_entities = {
             FeatureType.OPERATIONS: dispatcher.instance.num_operations,
@@ -54,6 +74,21 @@ class FeatureObserver(DispatcherObserver):
         }
         self.initialize_features()
 
+    @property
+    def feature_size(self) -> dict[FeatureType, int]:
+        """Returns the size of the features."""
+        if isinstance(self._feature_size, int):
+            return {
+                feature_type: self._feature_size
+                for feature_type in self.features
+            }
+        return self._feature_size
+
+    @property
+    def supported_feature_types(self) -> list[FeatureType]:
+        """Returns the supported feature types."""
+        return self._supported_feature_types
+
     def initialize_features(self):
         """Initializes the features based on the current state of the
         dispatcher."""
@@ -61,16 +96,16 @@ class FeatureObserver(DispatcherObserver):
     def update(self, scheduled_operation: ScheduledOperation):
         """Updates the features based on the scheduled operation.
 
-        By default, this method just calls `initialize_features`.
+        By default, this method just calls :meth:`initialize_features`.
 
         Args:
-            scheduled_operation:
+            ScheduledOperation:
                 The operation that has been scheduled.
         """
         self.initialize_features()
 
     def reset(self):
-        """Sets features to zero and calls to `initialize_features`."""
+        """Sets features to zero and calls to :meth:``initialize_features``."""
         self.set_features_to_zero()
         self.initialize_features()
 
@@ -88,21 +123,29 @@ class FeatureObserver(DispatcherObserver):
                 continue
             self.features[feature_type][:] = 0.0
 
-    @staticmethod
-    def get_feature_types_list(
+    def _get_feature_types_list(
+        self,
         feature_types: list[FeatureType] | FeatureType | None,
     ) -> list[FeatureType]:
         """Returns a list of feature types.
 
         Args:
             feature_types:
-                A list of feature types or a single feature type. If `None`,
+                A list of feature types or a single feature type. If ``None``,
                 all feature types are returned.
         """
         if isinstance(feature_types, FeatureType):
-            feature_types = [feature_types]
+            return [feature_types]
         if feature_types is None:
-            feature_types = list(FeatureType)
+            return self._supported_feature_types
+
+        for feature_type in feature_types:
+            if feature_type not in self._supported_feature_types:
+                raise ValidationError(
+                    f"Feature type {feature_type} is not supported."
+                    " Supported feature types are: "
+                    f"{self._supported_feature_types}"
+                )
         return feature_types
 
     def __str__(self):

job_shop_lib/dispatching/feature_observers/_is_completed_observer.py

@@ -0,0 +1,97 @@
+"""Home of the `IsCompletedObserver` class."""
+
+import numpy as np
+
+from job_shop_lib import ScheduledOperation
+from job_shop_lib.dispatching import (
+    Dispatcher,
+    DispatcherObserver,
+)
+from job_shop_lib.dispatching.feature_observers import (
+    FeatureObserver,
+    FeatureType,
+    RemainingOperationsObserver,
+)
+
+
+class IsCompletedObserver(FeatureObserver):
+    """Observer that adds a binary feature indicating whether each operation,
+    machine, or job has been completed."""
+
+    def __init__(
+        self,
+        dispatcher: Dispatcher,
+        feature_types: list[FeatureType] | FeatureType | None = None,
+        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.remaining_ops_per_job = np.zeros(
+            (dispatcher.instance.num_jobs, 1), dtype=int
+        )
+        super().__init__(
+            dispatcher,
+            feature_types=feature_types,
+            subscribe=subscribe,
+        )
+
+    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
+                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
+            )
+            self.features[FeatureType.MACHINES][
+                scheduled_operation.operation.machines, 0
+            ] = is_completed
+        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

job_shop_lib/dispatching/feature_observers/_is_ready_observer.py

@@ -0,0 +1,33 @@
+"""Home of the `IsReadyObserver` class."""
+
+from job_shop_lib.dispatching.feature_observers import (
+    FeatureObserver,
+    FeatureType,
+)
+
+
+class IsReadyObserver(FeatureObserver):
+    """Feature creator that adds a binary feature indicating if the operation
+    is ready to be dispatched."""
+
+    def initialize_features(self):
+        self.set_features_to_zero()
+        for feature_type, feature in self.features.items():
+            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]:
+        if feature_type == FeatureType.OPERATIONS:
+            return self._get_ready_operations()
+        if feature_type == FeatureType.MACHINES:
+            return self.dispatcher.available_machines()
+        if feature_type == FeatureType.JOBS:
+            return self.dispatcher.available_jobs()
+        raise ValueError(f"Feature type {feature_type} is not supported.")
+
+    def reset(self):
+        self.initialize_features()
+
+    def _get_ready_operations(self) -> list[int]:
+        available_operations = self.dispatcher.ready_operations()
+        return [operation.operation_id for operation in available_operations]

job_shop_lib/dispatching/feature_observers/{position_in_job_observer.py → _position_in_job_observer.py}

@@ -1,6 +1,5 @@
 """Home of the `PositionInJobObserver` class."""
 
-from job_shop_lib.dispatching import Dispatcher
 from job_shop_lib import ScheduledOperation
 from job_shop_lib.dispatching.feature_observers import (
     FeatureObserver,
@@ -15,13 +14,7 @@ class PositionInJobObserver(FeatureObserver):
     Positions are adjusted dynamically as operations are scheduled.
     """
 
-    def __init__(self, dispatcher: Dispatcher, subscribe: bool = True):
-        super().__init__(
-            dispatcher,
-            feature_types=[FeatureType.OPERATIONS],
-            feature_size=1,
-            subscribe=subscribe,
-        )
+    _supported_feature_types = [FeatureType.OPERATIONS]
 
     def initialize_features(self):
         for operation in self.dispatcher.unscheduled_operations():

job_shop_lib/dispatching/feature_observers/{remaining_operations_observer.py → _remaining_operations_observer.py}

@@ -1,7 +1,7 @@
 """Home of the `RemainingOperationsObserver` class."""
 
 from job_shop_lib import ScheduledOperation
-from job_shop_lib.dispatching import Dispatcher
+from job_shop_lib.dispatching import UnscheduledOperationsObserver
 from job_shop_lib.dispatching.feature_observers import (
     FeatureObserver,
     FeatureType,
@@ -12,38 +12,20 @@ class RemainingOperationsObserver(FeatureObserver):
     """Adds a feature indicating the number of remaining operations for each
     job and machine.
 
-    It does not support FeatureType.OPERATIONS.
+    It does not support :class:`FeatureType.OPERATIONS`.
     """
 
-    def __init__(
-        self,
-        dispatcher: Dispatcher,
-        feature_types: list[FeatureType] | FeatureType | None = None,
-        subscribe: bool = True,
-    ):
-        if feature_types is None:
-            feature_types = [FeatureType.MACHINES, FeatureType.JOBS]
-
-        if (
-            feature_types == FeatureType.OPERATIONS
-            or FeatureType.OPERATIONS in feature_types
-        ):
-            raise ValueError("FeatureType.OPERATIONS is not supported.")
-        super().__init__(
-            dispatcher,
-            feature_types=feature_types,
-            feature_size=1,
-            subscribe=subscribe,
-        )
+    _supported_feature_types = [FeatureType.MACHINES, FeatureType.JOBS]
 
     def initialize_features(self):
-        for operation in self.dispatcher.unscheduled_operations():
+        unscheduled_ops_observer = self.dispatcher.create_or_get_observer(
+            UnscheduledOperationsObserver
+        )
+        for operation in unscheduled_ops_observer.unscheduled_operations:
             if FeatureType.JOBS in self.features:
                 self.features[FeatureType.JOBS][operation.job_id, 0] += 1
             if FeatureType.MACHINES in self.features:
-                self.features[FeatureType.MACHINES][
-                    operation.machine_id, 0
-                ] += 1
+                self.features[FeatureType.MACHINES][operation.machines, 0] += 1
 
     def update(self, scheduled_operation: ScheduledOperation):
         if FeatureType.JOBS in self.features:

job_shop_lib/dispatching/rules/__init__.py

@@ -0,0 +1,51 @@
+"""Contains the dispatching rules for the job shop scheduling problem."""
+
+from ._dispatching_rules_functions import (
+    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,
+    shortest_processing_time_score,
+    first_come_first_served_score,
+    MostWorkRemainingScorer,
+    most_operations_remaining_score,
+    random_score,
+    observer_based_most_work_remaining_rule,
+)
+from ._machine_chooser_factory import (
+    MachineChooserType,
+    MachineChooser,
+    machine_chooser_factory,
+)
+
+from ._dispatching_rule_factory import (
+    dispatching_rule_factory,
+    DispatchingRuleType,
+)
+from ._dispatching_rule_solver import DispatchingRuleSolver
+
+
+__all__ = [
+    "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",
+    "shortest_processing_time_score",
+    "first_come_first_served_score",
+    "MostWorkRemainingScorer",
+    "most_operations_remaining_score",
+    "random_score",
+    "dispatching_rule_factory",
+    "DispatchingRuleType",
+    "MachineChooserType",
+    "machine_chooser_factory",
+    "MachineChooser",
+    "DispatchingRuleSolver",
+    "observer_based_most_work_remaining_rule",
+]

job_shop_lib/dispatching/rules/_dispatching_rule_factory.py

@@ -0,0 +1,82 @@
+"""Contains factory functions for creating dispatching rules, machine choosers,
+and pruning functions for the job shop scheduling problem.
+
+The factory functions create and return the appropriate functions based on the
+specified names or enums.
+"""
+
+from enum import Enum
+from collections.abc import Callable
+
+from job_shop_lib import Operation
+from job_shop_lib.exceptions import ValidationError
+from job_shop_lib.dispatching import Dispatcher
+from job_shop_lib.dispatching.rules import (
+    shortest_processing_time_rule,
+    first_come_first_served_rule,
+    most_operations_remaining_rule,
+    random_operation_rule,
+    most_work_remaining_rule,
+)
+
+
+class DispatchingRuleType(str, Enum):
+    """Enumeration of dispatching rules for the job shop scheduling problem."""
+
+    SHORTEST_PROCESSING_TIME = "shortest_processing_time"
+    FIRST_COME_FIRST_SERVED = "first_come_first_served"
+    MOST_WORK_REMAINING = "most_work_remaining"
+    MOST_OPERATIONS_REMAINING = "most_operations_remaining"
+    RANDOM = "random"
+
+
+def dispatching_rule_factory(
+    dispatching_rule: str | DispatchingRuleType,
+) -> Callable[[Dispatcher], Operation]:
+    """Creates and returns a dispatching rule function based on the specified
+    dispatching rule name.
+
+    The dispatching rule function determines the order in which operations are
+    selected for execution based on certain criteria such as shortest
+    processing time, first come first served, etc.
+
+    Args:
+        dispatching_rule: The name of the dispatching rule to be used.
+            Supported values are 'shortest_processing_time',
+            'first_come_first_served', 'most_work_remaining',
+            and 'random'.
+
+    Returns:
+        A function that takes a Dispatcher instance as input and returns an
+        Operation based on the specified dispatching rule.
+
+    Raises:
+        ValidationError:
+            If the dispatching_rule argument is not recognized or it is
+            not supported.
+    """
+    dispatching_rules: dict[
+        DispatchingRuleType,
+        Callable[[Dispatcher], Operation],
+    ] = {
+        DispatchingRuleType.SHORTEST_PROCESSING_TIME: (
+            shortest_processing_time_rule
+        ),
+        DispatchingRuleType.FIRST_COME_FIRST_SERVED: (
+            first_come_first_served_rule
+        ),
+        DispatchingRuleType.MOST_WORK_REMAINING: most_work_remaining_rule,
+        DispatchingRuleType.MOST_OPERATIONS_REMAINING: (
+            most_operations_remaining_rule
+        ),
+        DispatchingRuleType.RANDOM: random_operation_rule,
+    }
+
+    dispatching_rule = dispatching_rule.lower()
+    if dispatching_rule not in dispatching_rules:
+        raise ValidationError(
+            f"Dispatching rule {dispatching_rule} not recognized. Available "
+            f"dispatching rules: {', '.join(dispatching_rules)}."
+        )
+
+    return dispatching_rules[dispatching_rule]  # type: ignore[index]

job_shop_lib/dispatching/{dispatching_rule_solver.py → rules/_dispatching_rule_solver.py}

@@ -4,13 +4,15 @@ from collections.abc import Callable
 
 from job_shop_lib import JobShopInstance, Schedule, Operation, BaseSolver
 from job_shop_lib.dispatching import (
+    ready_operations_filter_factory,
+    Dispatcher,
+    ReadyOperationsFilterType,
+)
+from job_shop_lib.dispatching.rules import (
     dispatching_rule_factory,
     machine_chooser_factory,
-    pruning_function_factory,
-    DispatchingRule,
-    MachineChooser,
-    Dispatcher,
-    PruningFunction,
+    DispatchingRuleType,
+    MachineChooserType,
 )
 
 
@@ -34,15 +36,15 @@ class DispatchingRuleSolver(BaseSolver):
         self,
         dispatching_rule: (
             str | Callable[[Dispatcher], Operation]
-        ) = DispatchingRule.MOST_WORK_REMAINING,
+        ) = DispatchingRuleType.MOST_WORK_REMAINING,
         machine_chooser: (
             str | Callable[[Dispatcher, Operation], int]
-        ) = MachineChooser.FIRST,
+        ) = MachineChooserType.FIRST,
         pruning_function: (
             str
             | Callable[[Dispatcher, list[Operation]], list[Operation]]
             | None
-        ) = PruningFunction.DOMINATED_OPERATIONS,
+        ) = ReadyOperationsFilterType.DOMINATED_OPERATIONS,
     ):
         """Initializes the solver with the given dispatching rule, machine
         chooser and pruning function.
@@ -70,7 +72,9 @@ class DispatchingRuleSolver(BaseSolver):
         if isinstance(machine_chooser, str):
             machine_chooser = machine_chooser_factory(machine_chooser)
         if isinstance(pruning_function, str):
-            pruning_function = pruning_function_factory(pruning_function)
+            pruning_function = ready_operations_filter_factory(
+                pruning_function
+            )
 
         self.dispatching_rule = dispatching_rule
         self.machine_chooser = machine_chooser
@@ -83,7 +87,7 @@ class DispatchingRuleSolver(BaseSolver):
         dispatching rule algorithm."""
         if dispatcher is None:
             dispatcher = Dispatcher(
-                instance, pruning_function=self.pruning_function
+                instance, ready_operations_filter=self.pruning_function
             )
         while not dispatcher.schedule.is_complete():
             self.step(dispatcher)
@@ -105,15 +109,40 @@ class DispatchingRuleSolver(BaseSolver):
 
 if __name__ == "__main__":
     import time
+    import cProfile
+    import pstats
+    from io import StringIO
     from job_shop_lib.benchmarking import load_benchmark_instance
 
-    ta_instances = []
-    for i in range(1, 81):
-        ta_instances.append(load_benchmark_instance(f"ta{i:02d}"))
-    solver = DispatchingRuleSolver(dispatching_rule="most_work_remaining")
-    # cProfile.run("for instance in ta_instances: solver.solve(instance)")
+    # from job_shop_lib.dispatching.rules._dispatching_rules_functions import (
+    #     most_work_remaining_rule_2,
+    # )
+
+    ta_instances = [
+        load_benchmark_instance(f"ta{i:02d}") for i in range(1, 81)
+    ]
+    solver = DispatchingRuleSolver(
+        dispatching_rule="most_work_remaining", pruning_function=None
+    )
+
     start = time.perf_counter()
+
+    # Create a Profile object
+    profiler = cProfile.Profile()
+
+    # Run the code under profiling
+    profiler.enable()
     for instance_ in ta_instances:
         solver.solve(instance_)
+    profiler.disable()
+
     end = time.perf_counter()
+
+    # Print elapsed time
     print(f"Elapsed time: {end - start:.2f} seconds.")
+
+    # Print profiling results
+    s = StringIO()
+    ps = pstats.Stats(profiler, stream=s).sort_stats("cumulative")
+    profiler.print_stats("cumtime")  # Print top 20 time-consuming functions
+    # print(s.getvalue())