job-shop-lib 0.5.0__py3-none-any.whl → 1.0.0__py3-none-any.whl

job_shop_lib/dispatching/feature_observers/earliest_start_time_observer.py

@@ -1,156 +0,0 @@
-"""Home of the `EarliestStartTimeObserver` class."""
-
-import numpy as np
-
-from job_shop_lib.dispatching import Dispatcher
-from job_shop_lib.dispatching.feature_observers import (
-    FeatureObserver,
-    FeatureType,
-)
-from job_shop_lib.scheduled_operation import ScheduledOperation
-
-
-class EarliestStartTimeObserver(FeatureObserver):
-    """Observer that adds a feature indicating the earliest start time of
-    each operation, machine, and job in the graph."""
-
-    def __init__(
-        self,
-        dispatcher: Dispatcher,
-        feature_types: list[FeatureType] | FeatureType | None = None,
-        subscribe: bool = True,
-    ):
-
-        # Earliest start times initialization
-        # -------------------------------
-        squared_duration_matrix = dispatcher.instance.durations_matrix_array
-        self.earliest_start_times = np.hstack(
-            (
-                np.zeros((squared_duration_matrix.shape[0], 1)),
-                np.cumsum(squared_duration_matrix[:, :-1], axis=1),
-            )
-        )
-        self.earliest_start_times[np.isnan(squared_duration_matrix)] = np.nan
-        # -------------------------------
-        super().__init__(
-            dispatcher, feature_types, feature_size=1, subscribe=subscribe
-        )
-
-    def update(self, scheduled_operation: ScheduledOperation):
-        """Recomputes the earliest start times and calls the
-        `initialize_features` method.
-
-        The earliest start times is computed as the cumulative sum of the
-        previous unscheduled operations in the job plus the maximum of the
-        completion time of the last scheduled operation and the next available
-        time of the machine(s) the operation is assigned.
-
-        After that, we substract the current time.
-        """
-        # We compute the gap that the current scheduled operation could be
-        # adding to each job.
-        job_id = scheduled_operation.job_id
-        next_operation_idx = self.dispatcher.job_next_operation_index[job_id]
-        if next_operation_idx < len(self.dispatcher.instance.jobs[job_id]):
-            old_start_time = self.earliest_start_times[
-                job_id, next_operation_idx
-            ]
-            next_operation = self.dispatcher.instance.jobs[job_id][
-                next_operation_idx
-            ]
-            new_start_time = max(
-                scheduled_operation.end_time,
-                old_start_time,
-                self.dispatcher.earliest_start_time(next_operation),
-            )
-            gap = new_start_time - old_start_time
-            self.earliest_start_times[job_id, next_operation_idx:] += gap
-
-        # Now, we compute the gap that could be introduced by the new
-        # next_available_time of the machine.
-        operations_by_machine = self.dispatcher.instance.operations_by_machine
-        for operation in operations_by_machine[scheduled_operation.machine_id]:
-            if self.dispatcher.is_scheduled(operation):
-                continue
-            old_start_time = self.earliest_start_times[
-                operation.job_id, operation.position_in_job
-            ]
-            new_start_time = max(old_start_time, scheduled_operation.end_time)
-            gap = new_start_time - old_start_time
-            self.earliest_start_times[
-                operation.job_id, operation.position_in_job :
-            ] += gap
-
-        self.initialize_features()
-
-    def initialize_features(self):
-        """Initializes the features based on the current state of the
-        dispatcher."""
-        mapping = {
-            FeatureType.OPERATIONS: self._update_operation_features,
-            FeatureType.MACHINES: self._update_machine_features,
-            FeatureType.JOBS: self._update_job_features,
-        }
-        for feature_type in self.features:
-            mapping[feature_type]()
-
-    def _update_operation_features(self):
-        """Ravels the 2D array into a 1D array"""
-        current_time = self.dispatcher.current_time()
-        next_index = 0
-        for job_id, operations in enumerate(self.dispatcher.instance.jobs):
-            self.features[FeatureType.OPERATIONS][
-                next_index : next_index + len(operations), 0
-            ] = (
-                self.earliest_start_times[job_id, : len(operations)]
-                - current_time
-            )
-            next_index += len(operations)
-
-    def _update_machine_features(self):
-        """Picks the minimum start time of all operations that can be scheduled
-        on that machine"""
-        current_time = self.dispatcher.current_time()
-        operations_by_machine = self.dispatcher.instance.operations_by_machine
-        for machine_id, operations in enumerate(operations_by_machine):
-            min_earliest_start_time = min(
-                (
-                    self.earliest_start_times[
-                        operation.job_id, operation.position_in_job
-                    ]
-                    for operation in operations
-                    if not self.dispatcher.is_scheduled(operation)
-                ),
-                default=0,
-            )
-            self.features[FeatureType.MACHINES][machine_id, 0] = (
-                min_earliest_start_time - current_time
-            )
-
-    def _update_job_features(self):
-        """Picks the earliest start time of the next operation in the job"""
-        current_time = self.dispatcher.current_time()
-        for job_id, next_operation_idx in enumerate(
-            self.dispatcher.job_next_operation_index
-        ):
-            job_length = len(self.dispatcher.instance.jobs[job_id])
-            if next_operation_idx == job_length:
-                continue
-            self.features[FeatureType.JOBS][job_id, 0] = (
-                self.earliest_start_times[job_id, next_operation_idx]
-                - current_time
-            )
-
-
-if __name__ == "__main__":
-    squared_durations_matrix = np.array([[1, 1, 7], [5, 1, 1], [1, 3, 2]])
-    # Add a zeros column to the left of the matrix
-    cumulative_durations = np.hstack(
-        (
-            np.zeros((squared_durations_matrix.shape[0], 1)),
-            squared_durations_matrix[:, :-1],
-        )
-    )
-    # Set to nan the values that are not available
-    cumulative_durations[np.isnan(squared_durations_matrix)] = np.nan
-    print(cumulative_durations)

job_shop_lib/dispatching/feature_observers/factory.py

@@ -1,58 +0,0 @@
-"""Contains factory functions for creating node feature encoders."""
-
-from enum import Enum
-
-from job_shop_lib.dispatching.feature_observers import (
-    IsReadyObserver,
-    EarliestStartTimeObserver,
-    FeatureObserver,
-    DurationObserver,
-    IsScheduledObserver,
-    PositionInJobObserver,
-    RemainingOperationsObserver,
-    IsCompletedObserver,
-)
-
-
-class FeatureObserverType(str, Enum):
-    """Enumeration of node feature creator types for the job shop scheduling
-    problem."""
-
-    IS_READY = "is_ready"
-    EARLIEST_START_TIME = "earliest_start_time"
-    DURATION = "duration"
-    IS_SCHEDULED = "is_scheduled"
-    POSITION_IN_JOB = "position_in_job"
-    REMAINING_OPERATIONS = "remaining_operations"
-    IS_COMPLETED = "is_completed"
-    COMPOSITE = "composite"
-
-
-def feature_observer_factory(
-    node_feature_creator_type: str | FeatureObserverType,
-    **kwargs,
-) -> FeatureObserver:
-    """Creates and returns a node feature creator based on the specified
-    node feature creator type.
-
-    Args:
-        node_feature_creator_type:
-            The type of node feature creator to create.
-        **kwargs:
-            Additional keyword arguments to pass to the node
-            feature creator constructor.
-
-    Returns:
-        A node feature creator instance.
-    """
-    mapping: dict[FeatureObserverType, type[FeatureObserver]] = {
-        FeatureObserverType.IS_READY: IsReadyObserver,
-        FeatureObserverType.EARLIEST_START_TIME: EarliestStartTimeObserver,
-        FeatureObserverType.DURATION: DurationObserver,
-        FeatureObserverType.IS_SCHEDULED: IsScheduledObserver,
-        FeatureObserverType.POSITION_IN_JOB: PositionInJobObserver,
-        FeatureObserverType.REMAINING_OPERATIONS: RemainingOperationsObserver,
-        FeatureObserverType.IS_COMPLETED: IsCompletedObserver,
-    }
-    feature_creator = mapping[node_feature_creator_type]  # type: ignore[index]
-    return feature_creator(**kwargs)

job_shop_lib/dispatching/feature_observers/feature_observer.py

@@ -1,113 +0,0 @@
-"""Home of the `FeatureObserver` class and `FeatureType` enum."""
-
-import enum
-
-import numpy as np
-from job_shop_lib import ScheduledOperation
-from job_shop_lib.dispatching import Dispatcher, DispatcherObserver
-
-
-class FeatureType(str, enum.Enum):
-    """Types of features that can be extracted."""
-
-    OPERATIONS = "operations"
-    MACHINES = "machines"
-    JOBS = "jobs"
-
-
-class FeatureObserver(DispatcherObserver):
-    """Base class for feature observers."""
-
-    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 = self.get_feature_types_list(feature_types)
-        if isinstance(feature_size, int):
-            feature_size = {
-                feature_type: feature_size for feature_type in feature_types
-            }
-        super().__init__(dispatcher, is_singleton, subscribe)
-
-        number_of_entities = {
-            FeatureType.OPERATIONS: dispatcher.instance.num_operations,
-            FeatureType.MACHINES: dispatcher.instance.num_machines,
-            FeatureType.JOBS: dispatcher.instance.num_jobs,
-        }
-        self.feature_dimensions = {
-            feature_type: (
-                number_of_entities[feature_type],
-                feature_size[feature_type],
-            )
-            for feature_type in feature_types
-        }
-        self.features = {
-            feature_type: np.zeros(
-                self.feature_dimensions[feature_type],
-                dtype=np.float32,
-            )
-            for feature_type in feature_types
-        }
-        self.initialize_features()
-
-    def initialize_features(self):
-        """Initializes the features based on the current state of the
-        dispatcher."""
-
-    def update(self, scheduled_operation: ScheduledOperation):
-        """Updates the features based on the scheduled operation.
-
-        By default, this method just calls `initialize_features`.
-
-        Args:
-            scheduled_operation:
-                The operation that has been scheduled.
-        """
-        self.initialize_features()
-
-    def reset(self):
-        """Sets features to zero and calls to `initialize_features`."""
-        self.set_features_to_zero()
-        self.initialize_features()
-
-    def set_features_to_zero(
-        self, exclude: FeatureType | list[FeatureType] | None = None
-    ):
-        """Sets features to zero."""
-        if exclude is None:
-            exclude = []
-        if isinstance(exclude, FeatureType):
-            exclude = [exclude]
-
-        for feature_type in self.features:
-            if feature_type in exclude:
-                continue
-            self.features[feature_type][:] = 0.0
-
-    @staticmethod
-    def get_feature_types_list(
-        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`,
-                all feature types are returned.
-        """
-        if isinstance(feature_types, FeatureType):
-            feature_types = [feature_types]
-        if feature_types is None:
-            feature_types = list(FeatureType)
-        return feature_types
-
-    def __str__(self):
-        out = [self.__class__.__name__, ":\n"]
-        out.append("-" * len(out[0]))
-        for feature_type, feature in self.features.items():
-            out.append(f"\n{feature_type.value}:\n{feature}")
-        return "".join(out)

job_shop_lib/dispatching/feature_observers/is_completed_observer.py

@@ -1,98 +0,0 @@
-"""Home of the `IsCompletedObserver` class."""
-
-from typing import Iterable
-
-import numpy as np
-
-from job_shop_lib import ScheduledOperation
-from job_shop_lib.dispatching import Dispatcher
-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,
-    ):
-        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_size=1)
-
-    def initialize_features(self):
-        self._initialize_remaining_operations()
-
-    def update(self, scheduled_operation: ScheduledOperation):
-        if FeatureType.OPERATIONS in self.features:
-            # operation_id = scheduled_operation.operation.operation_id
-            # self.features[FeatureType.OPERATIONS][operation_id, 0] = 1
-            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:
-            machine_id = scheduled_operation.machine_id
-            self.remaining_ops_per_machine[machine_id, 0] -= 1
-            is_completed = self.remaining_ops_per_machine[machine_id, 0] == 0
-            self.features[FeatureType.MACHINES][machine_id, 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
-
-    def _initialize_remaining_operations(self):
-        remaining_ops_observer = self._get_remaining_operations_observer(
-            self.dispatcher, self.features
-        )
-        if remaining_ops_observer is not None:
-            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()
-                )
-            return
-
-        # If there is no remaining operations observer, we need to
-        # compute the remaining operations ourselves.
-        # We iterate over all operations using scheduled_operations
-        # instead of uncompleted_operations, because in this case
-        # they will output the same operations, and the former is slightly
-        # more efficient.
-        for operation in self.dispatcher.unscheduled_operations():
-            if FeatureType.JOBS in self.features:
-                self.remaining_ops_per_job[operation.job_id, 0] += 1
-            if FeatureType.MACHINES in self.features:
-                self.remaining_ops_per_machine[operation.machine_id, 0] += 1
-
-    def _get_remaining_operations_observer(
-        self, dispatcher: Dispatcher, feature_types: Iterable[FeatureType]
-    ) -> RemainingOperationsObserver | None:
-        for observer in dispatcher.subscribers:
-            if not isinstance(observer, RemainingOperationsObserver):
-                continue
-            has_same_features = all(
-                feature_type in observer.features
-                for feature_type in feature_types
-            )
-            if has_same_features:
-                return observer
-        return None

job_shop_lib/dispatching/feature_observers/is_ready_observer.py

@@ -1,40 +0,0 @@
-"""Home of the `IsReadyObserver` class."""
-
-from job_shop_lib.dispatching import Dispatcher
-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 __init__(
-        self,
-        dispatcher: Dispatcher,
-        feature_types: list[FeatureType] | FeatureType | None = None,
-        subscribe: bool = True,
-    ):
-        super().__init__(
-            dispatcher, feature_types, feature_size=1, subscribe=subscribe
-        )
-
-    def initialize_features(self):
-        self.set_features_to_zero()
-        for feature_type, feature in self.features.items():
-            node_ids = self._get_ready_nodes(feature_type)
-            feature[node_ids, 0] = 1.0
-
-    def _get_ready_nodes(self, feature_type: FeatureType) -> list[int]:
-        mapping = {
-            FeatureType.OPERATIONS: self._get_ready_operation_nodes,
-            FeatureType.MACHINES: self.dispatcher.available_machines,
-            FeatureType.JOBS: self.dispatcher.available_jobs,
-        }
-        return mapping[feature_type]()
-
-    def _get_ready_operation_nodes(self) -> list[int]:
-        available_operations = self.dispatcher.available_operations()
-        return [operation.operation_id for operation in available_operations]

job_shop_lib/dispatching/pruning_functions.py

@@ -1,116 +0,0 @@
-"""Contains functions to prune (filter) operations.
-
-This functions are used by the `Dispatcher` class to reduce the
-amount of available operations to choose from.
-"""
-
-from collections.abc import Callable, Iterable
-
-from job_shop_lib import Operation
-from job_shop_lib.dispatching import Dispatcher
-
-
-def create_composite_pruning_function(
-    pruning_functions: Iterable[
-        Callable[[Dispatcher, list[Operation]], list[Operation]]
-    ],
-) -> Callable[[Dispatcher, list[Operation]], list[Operation]]:
-    """Creates and returns a composite pruning strategy function based on the
-    specified list of pruning strategies.
-    The composite pruning strategy function filters out operations based on
-    the specified list of pruning strategies.
-    Args:
-        pruning_strategies:
-            A list of pruning strategies to be used. Supported values are
-            'dominated_operations' and 'non_immediate_machines'.
-    Returns:
-        A function that takes a Dispatcher instance and a list of Operation
-        instances as input and returns a list of Operation instances based on
-        the specified list of pruning strategies.
-    Raises:
-        ValueError: If any of the pruning strategies in the list are not
-            recognized or are not supported.
-    """
-
-    def composite_pruning_function(
-        dispatcher: Dispatcher, operations: list[Operation]
-    ) -> list[Operation]:
-        pruned_operations = operations
-        for pruning_function in pruning_functions:
-            pruned_operations = pruning_function(dispatcher, pruned_operations)
-
-        return pruned_operations
-
-    return composite_pruning_function
-
-
-def prune_dominated_operations(
-    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.
-    """
-
-    min_machine_end_times = _get_min_machine_end_times(dispatcher, operations)
-
-    non_dominated_operations: list[Operation] = []
-    for operation in operations:
-        # One benchmark instance has an operation with duration 0
-        if operation.duration == 0:
-            return [operation]
-        for machine_id in operation.machines:
-            start_time = dispatcher.start_time(operation, machine_id)
-            is_dominated = start_time >= min_machine_end_times[machine_id]
-            if not is_dominated:
-                non_dominated_operations.append(operation)
-                break
-
-    return non_dominated_operations
-
-
-def prune_non_immediate_machines(
-    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] = []
-    for operation in operations:
-        if any(
-            is_immediate_machine[machine_id]
-            for machine_id in operation.machines
-        ):
-            non_dominated_operations.append(operation)
-
-    return non_dominated_operations
-
-
-def _get_min_machine_end_times(
-    dispatcher: Dispatcher, available_operations: list[Operation]
-) -> list[int | float]:
-    end_times_per_machine = [float("inf")] * dispatcher.instance.num_machines
-    for op in available_operations:
-        for machine_id in op.machines:
-            start_time = dispatcher.start_time(op, machine_id)
-            end_times_per_machine[machine_id] = min(
-                end_times_per_machine[machine_id], start_time + op.duration
-            )
-    return end_times_per_machine
-
-
-def _get_immediate_machines(
-    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
-    # We can't use the current_time directly because it will cause
-    # an infinite loop.
-    current_time = self.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:
-                working_machines[machine_id] = True
-    return working_machines

job_shop_lib/generators/__init__.py

@@ -1,7 +0,0 @@
-"""Package for generating job shop instances."""
-
-from job_shop_lib.generators.basic_generator import BasicGenerator
-
-__all__ = [
-    "BasicGenerator",
-]