job-shop-lib 1.3.0__py3-none-any.whl → 1.5.0__py3-none-any.whl

job_shop_lib/__init__.py

@@ -19,7 +19,7 @@ from job_shop_lib._schedule import Schedule
 from job_shop_lib._base_solver import BaseSolver, Solver
 
 
-__version__ = "1.3.0"
+__version__ = "1.5.0"
 
 __all__ = [
     "Operation",

job_shop_lib/_job_shop_instance.py

@@ -3,8 +3,10 @@
 from __future__ import annotations
 
 import os
+from collections.abc import Sequence
 import functools
 from typing import Any
+import warnings
 
 import numpy as np
 from numpy.typing import NDArray
@@ -40,6 +42,9 @@ class JobShopInstance:
         is_flexible
         durations_matrix
         machines_matrix
+        release_dates_matrix
+        deadlines_matrix
+        due_dates_matrix
         durations_matrix_array
         machines_matrix_array
         operations_by_machine
@@ -92,6 +97,24 @@ class JobShopInstance:
         self.name: str = name
         self.metadata: dict[str, Any] = metadata
 
+        deprecated_keys = {
+            "release_dates_matrix",
+            "deadlines_matrix",
+            "due_dates_matrix",
+        }
+        if any(key in self.metadata for key in deprecated_keys):
+            warnings.warn(
+                "The use of 'release_dates_matrix', 'deadlines_matrix', or "
+                "'due_dates_matrix' in metadata is deprecated."
+                "Please add these attributes "
+                "directly to the Operation class. Not doing so may cause bugs "
+                "when using the dispatching module.You can use the "
+                "`JobShopInstance.from_matrices` method to create an "
+                "instance from 2D sequences. ",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+
     def set_operation_attributes(self):
         """Sets the ``job_id``, ``position_in_job``, and ``operation_id``
         attributes for each operation in the instance.
@@ -196,14 +219,25 @@ class JobShopInstance:
                     "duration_matrix": self.durations_matrix,
                     "machines_matrix": self.machines_matrix,
                     "metadata": self.metadata,
+                    # Optionally (if the instance has them):
+                    "release_dates_matrix": self.release_dates_matrix,
+                    "deadlines_matrix": self.deadlines_matrix,
+                    "due_dates_matrix": self.due_dates_matrix,
                 }
         """
-        return {
+        data = {
             "name": self.name,
             "duration_matrix": self.durations_matrix,
             "machines_matrix": self.machines_matrix,
             "metadata": self.metadata,
         }
+        if self.has_release_dates:
+            data["release_dates_matrix"] = self.release_dates_matrix
+        if self.has_deadlines:
+            data["deadlines_matrix"] = self.deadlines_matrix
+        if self.has_due_dates:
+            data["due_dates_matrix"] = self.due_dates_matrix
+        return data
 
     @classmethod
     def from_matrices(
@@ -212,6 +246,9 @@ class JobShopInstance:
         machines_matrix: list[list[list[int]]] | list[list[int]],
         name: str = "JobShopInstance",
         metadata: dict[str, Any] | None = None,
+        release_dates_matrix: list[list[int]] | None = None,
+        deadlines_matrix: list[list[int | None]] | None = None,
+        due_dates_matrix: list[list[int | None]] | None = None,
     ) -> JobShopInstance:
         """Creates a :class:`JobShopInstance` from duration and machines
         matrices.
@@ -219,16 +256,26 @@ class JobShopInstance:
         Args:
             duration_matrix:
                 A list of lists of integers. The i-th list contains the
-                durations of the operations of the job with id i.
+                durations of the operations of the job with id ``i``.
             machines_matrix:
                 A list of lists of lists of integers if the
                 instance is flexible, or a list of lists of integers if the
                 instance is not flexible. The i-th list contains the machines
-                in which the operations of the job with id i can be processed.
+                in which the operations of the job with id ``i`` can be
+                processed.
             name:
                 A string with the name of the instance.
             metadata:
                 A dictionary with additional information about the instance.
+            release_dates_matrix:
+                A list of lists of integers. The i-th list contains the
+                release dates of the operations of the job with id ``i``.
+            deadlines_matrix:
+                A list of lists of optional integers. The i-th list contains
+                the deadlines of the operations of the job with id ``i``.
+            due_dates_matrix:
+                A list of lists of optional integers. The i-th list contains
+                the due dates of the operations of the job with id ``i``.
 
         Returns:
             A :class:`JobShopInstance` object.
@@ -241,8 +288,29 @@ class JobShopInstance:
             for position_in_job in range(num_operations):
                 duration = duration_matrix[job_id][position_in_job]
                 machines = machines_matrix[job_id][position_in_job]
+                release_date = (
+                    release_dates_matrix[job_id][position_in_job]
+                    if release_dates_matrix
+                    else 0
+                )
+                deadline = (
+                    deadlines_matrix[job_id][position_in_job]
+                    if deadlines_matrix
+                    else None
+                )
+                due_date = (
+                    due_dates_matrix[job_id][position_in_job]
+                    if due_dates_matrix
+                    else None
+                )
                 jobs[job_id].append(
-                    Operation(duration=duration, machines=machines)
+                    Operation(
+                        duration=duration,
+                        machines=machines,
+                        release_date=release_date,
+                        deadline=deadline,
+                        due_date=due_date,
+                    )
                 )
 
         metadata = {} if metadata is None else metadata
@@ -289,6 +357,21 @@ class JobShopInstance:
             for job in self.jobs
         )
 
+    @functools.cached_property
+    def has_release_dates(self) -> bool:
+        """Returns ``True`` if any operation has a release date > 0."""
+        return any(op.release_date > 0 for job in self.jobs for op in job)
+
+    @functools.cached_property
+    def has_deadlines(self) -> bool:
+        """Returns ``True`` if any operation has a deadline."""
+        return any(op.deadline is not None for job in self.jobs for op in job)
+
+    @functools.cached_property
+    def has_due_dates(self) -> bool:
+        """Returns ``True`` if any operation has a due date."""
+        return any(op.due_date is not None for job in self.jobs for op in job)
+
     @functools.cached_property
     def durations_matrix(self) -> list[list[int]]:
         """Returns the duration matrix of the instance.
@@ -330,23 +413,75 @@ class JobShopInstance:
             [operation.machine_id for operation in job] for job in self.jobs
         ]
 
+    @functools.cached_property
+    def release_dates_matrix(self) -> list[list[int]]:
+        """Returns the release dates matrix of the instance.
+
+        The release date of the operation with ``job_id`` i and
+        ``position_in_job`` j is stored in the i-th position of the j-th list
+        of the returned matrix.
+        """
+        return [
+            [operation.release_date for operation in job] for job in self.jobs
+        ]
+
+    @functools.cached_property
+    def deadlines_matrix(self) -> list[list[int | None]]:
+        """Returns the deadlines matrix of the instance.
+
+        The deadline of the operation with ``job_id`` i and
+        ``position_in_job`` j is stored in the i-th position of the j-th list
+        of the returned matrix.
+        """
+        return [[operation.deadline for operation in job] for job in self.jobs]
+
+    @functools.cached_property
+    def due_dates_matrix(self) -> list[list[int | None]]:
+        """Returns the due dates matrix of the instance.
+
+        The due date of the operation with ``job_id`` i and
+        ``position_in_job`` j is stored in the i-th position of the j-th list
+        of the returned matrix.
+        """
+        return [[operation.due_date for operation in job] for job in self.jobs]
+
     @functools.cached_property
     def durations_matrix_array(self) -> NDArray[np.float32]:
         """Returns the duration matrix of the instance as a numpy array.
 
-        The returned array has shape (``num_jobs``,
-        ``max_num_operations_per_job``).
-        Non-existing operations are filled with ``np.nan``.
+        If the jobs have different number of operations, the matrix is
+        padded with ``np.nan`` to make it rectangular.
+        """
+        return self._fill_matrix_with_nans_2d(self.durations_matrix)
 
-        Example:
-            >>> jobs = [[Operation(0, 2), Operation(1, 3)], [Operation(0, 4)]]
-            >>> instance = JobShopInstance(jobs)
-            >>> instance.durations_matrix_array
-            array([[ 2.,  3.],
-                   [ 4., nan]], dtype=float32)
+    @functools.cached_property
+    def release_dates_matrix_array(self) -> NDArray[np.float32]:
+        """Returns the release dates matrix of the instance as a numpy array.
+
+        If the jobs have different number of operations, the matrix is
+        padded with ``np.nan`` to make it rectangular.
         """
-        duration_matrix = self.durations_matrix
-        return self._fill_matrix_with_nans_2d(duration_matrix)
+        return self._fill_matrix_with_nans_2d(self.release_dates_matrix)
+
+    @functools.cached_property
+    def deadlines_matrix_array(self) -> NDArray[np.float32]:
+        """Returns the deadlines matrix of the instance as a numpy array.
+
+        If the jobs have different number of operations, the matrix is
+        padded with ``np.nan`` to make it rectangular. None values are also
+        converted to ``np.nan``.
+        """
+        return self._fill_matrix_with_nans_2d(self.deadlines_matrix)
+
+    @functools.cached_property
+    def due_dates_matrix_array(self) -> NDArray[np.float32]:
+        """Returns the due dates matrix of the instance as a numpy array.
+
+        If the jobs have different number of operations, the matrix is
+        padded with ``np.nan`` to make it rectangular. None values are also
+        converted to ``np.nan``.
+        """
+        return self._fill_matrix_with_nans_2d(self.due_dates_matrix)
 
     @functools.cached_property
     def machines_matrix_array(self) -> NDArray[np.float32]:
@@ -474,13 +609,13 @@ class JobShopInstance:
 
     @staticmethod
     def _fill_matrix_with_nans_2d(
-        matrix: list[list[int]],
+        matrix: Sequence[Sequence[int | None]],
     ) -> NDArray[np.float32]:
-        """Fills a matrix with ``np.nan`` values.
+        """Creates a 2D numpy array padded with ``np.nan`` values.
 
         Args:
             matrix:
-                A list of lists of integers.
+                A list of lists of integers or Nones.
 
         Returns:
             A numpy array with the same shape as the input matrix, filled with
@@ -491,14 +626,17 @@ class JobShopInstance:
             (len(matrix), max_length), np.nan, dtype=np.float32
         )
         for i, row in enumerate(matrix):
-            squared_matrix[i, : len(row)] = row
+            processed_row = [
+                item if item is not None else np.nan for item in row
+            ]
+            squared_matrix[i, : len(processed_row)] = processed_row
         return squared_matrix
 
     @staticmethod
     def _fill_matrix_with_nans_3d(
         matrix: list[list[list[int]]],
     ) -> NDArray[np.float32]:
-        """Fills a 3D matrix with ``np.nan`` values.
+        """Creates a 3D numpy array padded with ``np.nan`` values.
 
         Args:
             matrix:
@@ -522,9 +660,3 @@ class JobShopInstance:
             for j, inner_row in enumerate(row):
                 squared_matrix[i, j, : len(inner_row)] = inner_row
         return squared_matrix
-
-
-if __name__ == "__main__":
-    import doctest
-
-    doctest.testmod()

job_shop_lib/_operation.py

@@ -30,6 +30,16 @@ class Operation:
             an integer.
         duration:
             The time it takes to perform the operation.
+        release_date:
+            The earliest moment this operation can be scheduled to start.
+            Defaults to ``0``.
+        deadline:
+            A hard cutoff time by which the job must be finished. A schedule
+            is invalid if the job completes after this time. Defaults to
+            ``None``.
+        due_date:
+            The target completion time for the job. Finishing late is allowed
+            but incurs a penalty (e.g., tardiness). Defaults to ``None``.
     """
 
     __slots__ = {
@@ -42,6 +52,20 @@ class Operation:
             "The time it takes to perform the operation. Often referred"
             " to as the processing time."
         ),
+        "release_date": (
+            "The earliest moment this operation can be scheduled to start. "
+            "Defaults to ``0``."
+        ),
+        "deadline": (
+            "A hard cutoff time by which the job must be finished. A schedule "
+            "is invalid if the job completes after this time. Defaults to "
+            "``None``."
+        ),
+        "due_date": (
+            "The target completion time for the job. Finishing late is "
+            "allowed but incurs a penalty (e.g., tardiness). Defaults to "
+            "``None``."
+        ),
         "job_id": (
             "The id of the job the operation belongs to. Defaults to -1. "
             "It is usually set by the :class:`JobShopInstance` class after "
@@ -59,11 +83,21 @@ class Operation:
         ),
     }
 
-    def __init__(self, machines: int | list[int], duration: int):
+    def __init__(
+        self,
+        machines: int | list[int],
+        duration: int,
+        release_date: int = 0,
+        deadline: int | None = None,
+        due_date: int | None = None,
+    ):
         self.machines: list[int] = (
             [machines] if isinstance(machines, int) else machines
         )
         self.duration: int = duration
+        self.release_date: int = release_date
+        self.deadline: int | None = deadline
+        self.due_date: int | None = due_date
 
         # Defined outside the class by the JobShopInstance class:
         self.job_id: int = -1
@@ -93,9 +127,9 @@ class Operation:
     def is_initialized(self) -> bool:
         """Returns whether the operation has been initialized."""
         return (
-            self.job_id == -1
-            or self.position_in_job == -1
-            or self.operation_id == -1
+            self.job_id != -1
+            and self.position_in_job != -1
+            and self.operation_id != -1
         )
 
     def __hash__(self) -> int:
@@ -104,7 +138,16 @@ class Operation:
     def __eq__(self, value: object) -> bool:
         if not isinstance(value, Operation):
             return False
-        return self.__slots__ == value.__slots__
+        return (
+            self.machines == value.machines
+            and self.duration == value.duration
+            and self.release_date == value.release_date
+            and self.deadline == value.deadline
+            and self.due_date == value.due_date
+            and self.job_id == value.job_id
+            and self.position_in_job == value.position_in_job
+            and self.operation_id == value.operation_id
+        )
 
     def __repr__(self) -> str:
         machines = (

job_shop_lib/constraint_programming/_ortools_solver.py

@@ -112,16 +112,12 @@ class ORToolsSolver(BaseSolver):
         problem.
 
         Args:
-            instance:
-                The job shop instance to be solved.
-            arrival_times:
-                Optional arrival times for each operation.
-                If provided, the solver will ensure that operations do not
-                start before their respective arrival times.
-            deadlines:
-                Optional deadlines for each operation.
-                If provided, the solver will ensure that operations are
-                completed before their respective deadlines.
+            instance: The job shop instance to be solved.
+
+            .. note::
+                If provided, `arrival_times` and `deadlines` will override the
+                `release_date` and `deadline` attributes of the operations,
+                respectively.
 
         Returns:
             The best schedule found by the solver.
@@ -225,9 +221,12 @@ class ORToolsSolver(BaseSolver):
         """Creates two variables for each operation: start and end time."""
         for job in instance.jobs:
             for operation in job:
-                # Initial Naive Bounds
-                lower_bound = 0
-                upper_bound = instance.total_duration
+                lower_bound = operation.release_date
+                upper_bound = (
+                    instance.total_duration
+                    if operation.deadline is None
+                    else operation.deadline
+                )
 
                 if arrival_times is not None:
                     lower_bound = arrival_times[operation.job_id][

job_shop_lib/dispatching/_dispatcher.py

@@ -25,9 +25,8 @@ def no_setup_time_calculator(
 ) -> int:
     """Default start time calculator that implements the standard behavior.
 
-    The start time is the maximum of the next available time for the
-    machine and the next available time for the job to which the
-    operation belongs.
+    The start time is the maximum of the machine's next available time, the
+    job's next available time, and the operation's release date.
 
     Args:
         dispatcher:
@@ -44,6 +43,7 @@ def no_setup_time_calculator(
     return max(
         dispatcher.machine_next_available_time[machine_id],
         dispatcher.job_next_available_time[operation.job_id],
+        operation.release_date,
     )
 
 
@@ -552,7 +552,9 @@ class Dispatcher:
             for machine_id in operation.machines
         )
         job_start_time = self._job_next_available_time[operation.job_id]
-        return max(machine_earliest_start_time, job_start_time)
+        return max(
+            machine_earliest_start_time, job_start_time, operation.release_date
+        )
 
     def remaining_duration(
         self, scheduled_operation: ScheduledOperation
@@ -632,7 +634,11 @@ class Dispatcher:
     def is_ongoing(self, scheduled_operation: ScheduledOperation) -> bool:
         """Checks if the given operation is currently being processed."""
         current_time = self.current_time()
-        return scheduled_operation.start_time <= current_time
+        return (
+            scheduled_operation.start_time
+            <= current_time
+            < scheduled_operation.end_time
+        )
 
     def next_operation(self, job_id: int) -> Operation:
         """Returns the next operation to be scheduled for the given job.

job_shop_lib/dispatching/_ready_operation_filters.py

@@ -88,6 +88,8 @@ def filter_non_immediate_operations(
     min_start_time = dispatcher.min_start_time(operations)
     immediate_operations: list[Operation] = []
     for operation in operations:
+        if operation.release_date > min_start_time:
+            continue
         start_time = dispatcher.earliest_start_time(operation)
         if start_time == min_start_time:
             immediate_operations.append(operation)

job_shop_lib/dispatching/feature_observers/__init__.py

@@ -14,6 +14,7 @@ dispatcher.
     PositionInJobObserver
     RemainingOperationsObserver
     IsCompletedObserver
+    DatesObserver
     FeatureObserverType
     feature_observer_factory
     FeatureObserverConfig
@@ -41,6 +42,7 @@ from ._is_scheduled_observer import IsScheduledObserver
 from ._position_in_job_observer import PositionInJobObserver
 from ._remaining_operations_observer import RemainingOperationsObserver
 from ._is_completed_observer import IsCompletedObserver
+from ._dates_observer import DatesObserver
 from ._factory import (
     FeatureObserverType,
     feature_observer_factory,
@@ -60,6 +62,7 @@ __all__ = [
     "PositionInJobObserver",
     "RemainingOperationsObserver",
     "IsCompletedObserver",
+    "DatesObserver",
     "FeatureObserverType",
     "feature_observer_factory",
     "FeatureObserverConfig",

job_shop_lib/dispatching/feature_observers/_dates_observer.py

@@ -0,0 +1,162 @@
+"""Home of the `DatesObserver` class."""
+
+from typing import Literal
+
+import numpy as np
+
+from job_shop_lib import ScheduledOperation, JobShopInstance
+from job_shop_lib.dispatching import Dispatcher
+from job_shop_lib.dispatching.feature_observers import (
+    FeatureObserver,
+    FeatureType,
+)
+
+Attribute = Literal["release_date", "deadline", "due_date"]
+
+
+class DatesObserver(FeatureObserver):
+    """Observes time-related attributes of operations.
+
+    This observer tracks attributes like release date, deadline, and
+    due date for each operation in the job shop instance. The attributes to
+    be observed can be specified during initialization.
+
+    The values are stored in a numpy array of shape ``(num_operations,
+    num_attributes)``, where ``num_attributes`` is the number of attributes
+    being observed.
+
+    All attributes are updated based on the current time of the dispatcher so
+    that they reflect the relative time remaining until the event occurs:
+    (attribute - current_time). This means that the values will be negative if
+    the event is in the past.
+
+    Args:
+        dispatcher:
+            The :class:`~job_shop_lib.dispatching.Dispatcher` to observe.
+        subscribe:
+            If ``True``, the observer is subscribed to the dispatcher upon
+            initialization. Otherwise, the observer must be subscribed later
+            or manually updated.
+        attributes_to_observe:
+            A list of attributes to observe. If ``None``, all available time
+            attributes (release_date, deadline, due_date) will be
+            observed, provided they exist in the instance.
+    """
+
+    _supported_feature_types = [FeatureType.OPERATIONS]
+
+    __slots__ = {
+        "attributes_to_observe": "List of attributes to observe.",
+        "_attribute_map": "Maps attributes to their column index.",
+    }
+
+    def __init__(
+        self,
+        dispatcher: Dispatcher,
+        *,
+        subscribe: bool = True,
+        attributes_to_observe: list[Attribute] | None = None,
+        feature_types: FeatureType | list[FeatureType] | None = None,
+    ):
+        self.attributes_to_observe = self._determine_attributes_to_observe(
+            dispatcher.instance, attributes_to_observe
+        )
+        self._attribute_map = {
+            attr: i for i, attr in enumerate(self.attributes_to_observe)
+        }
+        self._previous_current_time = 0
+        super().__init__(
+            dispatcher,
+            subscribe=subscribe,
+            feature_types=feature_types,
+        )
+
+    @property
+    def feature_sizes(self) -> dict[FeatureType, int]:
+        return {
+            FeatureType.OPERATIONS: len(self.attributes_to_observe),
+        }
+
+    @property
+    def attribute_map(self) -> dict[Attribute, int]:
+        """Maps attributes to their column index in the features array."""
+        return self._attribute_map
+
+    def initialize_features(self):
+        """Initializes the features for the operations.
+
+        This method sets up the features for the operations based on the
+        attributes to observe. It creates a numpy array with the shape
+        (num_operations, num_attributes) and fills it with the corresponding
+        values from the job shop instance. Note that the matrix may contain
+        ``np.nan`` values for operations that do not have deadlines or
+        due dates.
+
+        .. seealso::
+            - :meth:`job_shop_lib.JobShopInstance.release_dates_matrix_array`
+            - :meth:`job_shop_lib.JobShopInstance.deadlines_matrix_array`
+            - :meth:`job_shop_lib.JobShopInstance.due_dates_matrix_array`
+        """
+        self.features = {
+            FeatureType.OPERATIONS: np.zeros(
+                (
+                    self.dispatcher.instance.num_operations,
+                    len(self.attributes_to_observe),
+                ),
+                dtype=np.float32,
+            )
+        }
+        self._previous_current_time = self.dispatcher.current_time()
+        release_dates_matrix = (
+            self.dispatcher.instance.release_dates_matrix_array
+        )
+        valid_operations_mask = ~np.isnan(release_dates_matrix.flatten())
+
+        for attr, col_idx in self._attribute_map.items():
+            matrix = getattr(self.dispatcher.instance, f"{attr}s_matrix_array")
+            values = np.array(matrix).flatten()
+            valid_values = values[valid_operations_mask]
+            self.features[FeatureType.OPERATIONS][:, col_idx] = valid_values
+
+    def update(self, scheduled_operation: ScheduledOperation):
+        """Updates the features based on the scheduled operation.
+
+        This method updates the features by subtracting the current time from
+        the initial release date, deadline, and due date attributes of the
+        operations.
+
+        Args:
+            scheduled_operation:
+                The scheduled operation that has just been processed. It is
+                not used in this observer, but is required by the
+                :meth:`FeatureObserver.update` method.
+        """
+        current_time = self.dispatcher.current_time()
+        elapsed_time = current_time - self._previous_current_time
+        self._previous_current_time = current_time
+        cols = [
+            self._attribute_map[attr]
+            for attr in self.attributes_to_observe
+        ]
+        self.features[FeatureType.OPERATIONS][:, cols] -= elapsed_time
+
+    def _determine_attributes_to_observe(
+        self,
+        instance: JobShopInstance,
+        attributes_to_observe: list[Attribute] | None,
+    ) -> list[Attribute]:
+        if attributes_to_observe:
+            return attributes_to_observe
+
+        default_attributes: list[Attribute] = []
+        if instance.has_release_dates:
+            default_attributes.append("release_date")
+        if instance.has_deadlines:
+            default_attributes.append("deadline")
+        if instance.has_due_dates:
+            default_attributes.append("due_date")
+        return default_attributes
+
+    def reset(self):
+        """Calls :meth:`initialize_features`"""
+        self.initialize_features()

job_shop_lib/dispatching/feature_observers/_duration_observer.py

@@ -77,12 +77,13 @@ class DurationObserver(FeatureObserver):
             self.features[FeatureType.JOBS][job_id, 0] = job_duration
 
     def _update_operation_durations(
-        self, scheduled_operation: ScheduledOperation
+        self, unused_scheduled_operation: ScheduledOperation
     ):
-        operation_id = scheduled_operation.operation.operation_id
-        self.features[FeatureType.OPERATIONS][operation_id, 0] = (
-            self.dispatcher.remaining_duration(scheduled_operation)
-        )
+        for scheduled_operation in self.dispatcher.ongoing_operations():
+            operation_id = scheduled_operation.operation.operation_id
+            self.features[FeatureType.OPERATIONS][operation_id, 0] = (
+                self.dispatcher.remaining_duration(scheduled_operation)
+            )
 
     def _update_machine_durations(
         self, scheduled_operation: ScheduledOperation

job_shop_lib/dispatching/rules/__init__.py

@@ -18,6 +18,7 @@ Dispatching rules:
     :nosignatures:
 
     shortest_processing_time_rule
+    largest_processing_time_rule
     first_come_first_served_rule
     most_work_remaining_rule
     most_operations_remaining_rule
@@ -32,6 +33,7 @@ Dispatching rule scorers:
     :nosignatures:
 
     shortest_processing_time_score
+    largest_processing_time_score
     first_come_first_served_score
     MostWorkRemainingScorer
     most_operations_remaining_score
@@ -45,6 +47,8 @@ from ._dispatching_rules_functions import (
     most_work_remaining_rule,
     most_operations_remaining_rule,
     random_operation_rule,
+    largest_processing_time_score,
+    largest_processing_time_rule,
     score_based_rule,
     score_based_rule_with_tie_breaker,
     shortest_processing_time_score,
@@ -78,6 +82,8 @@ __all__ = [
     "most_work_remaining_rule",
     "most_operations_remaining_rule",
     "random_operation_rule",
+    "largest_processing_time_score",
+    "largest_processing_time_rule",
     "score_based_rule",
     "score_based_rule_with_tie_breaker",
     "observer_based_most_work_remaining_rule",

job_shop_lib/dispatching/rules/_dispatching_rule_factory.py

@@ -17,6 +17,7 @@ from job_shop_lib.dispatching.rules import (
     most_operations_remaining_rule,
     random_operation_rule,
     most_work_remaining_rule,
+    largest_processing_time_rule,
 )
 
 
@@ -24,6 +25,7 @@ class DispatchingRuleType(str, Enum):
     """Enumeration of dispatching rules for the job shop scheduling problem."""
 
     SHORTEST_PROCESSING_TIME = "shortest_processing_time"
+    LARGEST_PROCESSING_TIME = "largest_processing_time"
     FIRST_COME_FIRST_SERVED = "first_come_first_served"
     MOST_WORK_REMAINING = "most_work_remaining"
     MOST_OPERATIONS_REMAINING = "most_operations_remaining"
@@ -62,6 +64,9 @@ def dispatching_rule_factory(
         DispatchingRuleType.SHORTEST_PROCESSING_TIME: (
             shortest_processing_time_rule
         ),
+        DispatchingRuleType.LARGEST_PROCESSING_TIME: (
+            largest_processing_time_rule
+        ),
         DispatchingRuleType.FIRST_COME_FIRST_SERVED: (
             first_come_first_served_rule
         ),

job_shop_lib/dispatching/rules/_dispatching_rules_functions.py

@@ -26,6 +26,37 @@ def shortest_processing_time_rule(dispatcher: Dispatcher) -> Operation:
     )
 
 
+def largest_processing_time_rule(dispatcher: Dispatcher) -> Operation:
+    """Dispatches the operation with the longest duration."""
+    return max(
+        dispatcher.available_operations(),
+        key=lambda operation: operation.duration,
+    )
+
+
+def largest_processing_time_score(dispatcher: Dispatcher) -> list[int]:
+    """Scores each job based on the duration of the next operation.
+
+    The score is the duration of the next operation in each job.
+    Jobs with longer next operations will have higher scores.
+
+    Args:
+        dispatcher:
+            The :class:`~job_shop_lib.dispatching.Dispatcher` instance
+            containing the job shop instance and the current state of the
+            schedule.
+
+    Returns:
+        A list of scores for each job, where the score is the duration of
+        the next operation in that job.
+    """
+    num_jobs = dispatcher.instance.num_jobs
+    scores = [0] * num_jobs
+    for operation in dispatcher.available_operations():
+        scores[operation.job_id] = operation.duration
+    return scores
+
+
 def first_come_first_served_rule(dispatcher: Dispatcher) -> Operation:
     """Dispatches the operation with the lowest position in job."""
     return min(

job_shop_lib/generation/_utils.py

@@ -98,9 +98,7 @@ def generate_machine_matrix_without_recirculation(
         (num_jobs, 1),
     )
     # Shuffle the columns:
-    machine_matrix = np.apply_along_axis(
-        rng.permutation, 1, machine_matrix
-    )
+    machine_matrix = np.apply_along_axis(rng.permutation, 1, machine_matrix)
     return machine_matrix
 
 

{job_shop_lib-1.3.0.dist-info → job_shop_lib-1.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: job-shop-lib
-Version: 1.3.0
+Version: 1.5.0
 Summary: An easy-to-use and modular Python library for the Job Shop Scheduling Problem (JSSP)
 License: MIT
 Author: Pabloo22

{job_shop_lib-1.3.0.dist-info → job_shop_lib-1.5.0.dist-info}/RECORD

@@ -1,26 +1,27 @@
-job_shop_lib/__init__.py,sha256=FHzL2Kx7_4FCgaaLxzb_RdTRDQgF-CraofLgc2IdSqs,639
+job_shop_lib/__init__.py,sha256=vJ_HFv-mEpI6ejngfGDE4aTMgYvFR3kYm8nkFyGrMS8,639
 job_shop_lib/_base_solver.py,sha256=p17XmtufNc9Y481cqZUT45pEkUmmW1HWG53dfhIBJH8,1363
-job_shop_lib/_job_shop_instance.py,sha256=FkMBy9Yb8cNEGswI9vlN3Wh4mhtEX-QuDbKvSYUOXcM,18361
-job_shop_lib/_operation.py,sha256=lwCjgXwWlgESFuV3Yh4SCVofPGCd3hJU4vnK7peREac,4235
+job_shop_lib/_job_shop_instance.py,sha256=_92orxdi70645J7cQlRE1I0PebvpHRCP6958q9j2h18,24261
+job_shop_lib/_operation.py,sha256=JI5WjvRXNBeSpPOv3ZwSrUJ4jsVDJYKfMaDHYOaFYts,5945
 job_shop_lib/_schedule.py,sha256=3PgDZ-DZmlESh5TASNHTqW_8Z7XPVSF64knvXEGRIbM,12927
 job_shop_lib/_scheduled_operation.py,sha256=czrGr87EOTlO2NPolIN5CDigeiCzvQEyra5IZPwSFZc,2801
 job_shop_lib/benchmarking/__init__.py,sha256=JPnCw5mK7sADAW0HctVKHEDRw22afp9caNh2eUS36Ys,3290
 job_shop_lib/benchmarking/_load_benchmark.py,sha256=-cgyx0Kn6uAc3KdGFSQb6eUVQjQggmpVKOH9qusNkXI,2930
 job_shop_lib/benchmarking/benchmark_instances.json,sha256=F9EvyzFwVxiKAN6rQTsrMhsKstmyUmroyWduM7a00KQ,464841
 job_shop_lib/constraint_programming/__init__.py,sha256=kKQRUxxS_nVFUdXGnf4bQOD9mqrXxZZWElS753A4YiA,454
-job_shop_lib/constraint_programming/_ortools_solver.py,sha256=LMpfpgiU2etrtyVTKVKyZW1PVMrOG2TenWzfGuEGf2I,12710
+job_shop_lib/constraint_programming/_ortools_solver.py,sha256=trTQtqSL2F2PXxd9RPnFhxaY8blNcfFUhTdab5QP9VU,12585
 job_shop_lib/dispatching/__init__.py,sha256=gbgY1_lhergmXaDa-VYVUmxMpOKzYko0ONREVAt_QPc,2643
-job_shop_lib/dispatching/_dispatcher.py,sha256=KnV_Kry3Ie81WbKhdpRQtOMsuFDNCuh5Kp2ZnelM-R8,23835
+job_shop_lib/dispatching/_dispatcher.py,sha256=A54Q3_hm9Qy5Vfzeudj2QFxd9SWo9lqqBN55S6z-Who,23976
 job_shop_lib/dispatching/_dispatcher_observer_config.py,sha256=QF2d3rJWwmvutQBAkKxzQ1toJs6eMelT404LGS2z9HQ,2467
 job_shop_lib/dispatching/_factories.py,sha256=j3MhIwVXiq-B8JMit72ObvXSa2sdgWNhUD86gghL6Gg,4689
 job_shop_lib/dispatching/_history_observer.py,sha256=Vl8rQaxekUeEB-AyNxyC3c76zQakeh-rdri2iDnZvXw,610
 job_shop_lib/dispatching/_optimal_operations_observer.py,sha256=2EYxevjpeGMP3do-m0ZmtmjIjmNcxrWOSKzN_bW37gQ,4247
-job_shop_lib/dispatching/_ready_operation_filters.py,sha256=brhmhoyyoZ98wAEEfneZC-CD-aw9SerZHGMB1DpK8HY,5749
+job_shop_lib/dispatching/_ready_operation_filters.py,sha256=DcwPDIF1eqVR6s3DV4J3cumii0N_apC13XA-50wjlI0,5822
 job_shop_lib/dispatching/_start_time_calculators.py,sha256=N4kz3c4TmXbyFsY6ctxruYK2ucnjSVXWNMhvsUWFuDg,8192
 job_shop_lib/dispatching/_unscheduled_operations_observer.py,sha256=0he-j4OlvqtXAJZD5x1nuBnUKqZUfftVx9NT3CVxPyg,2708
-job_shop_lib/dispatching/feature_observers/__init__.py,sha256=EuJLvSpJpoXUK8A4UuC2k6Mpa293ZR3oCnnvYivIBtU,2240
+job_shop_lib/dispatching/feature_observers/__init__.py,sha256=Pzud4tuO_t72d9KY_nEH-stGOvKUTNjo_6GeWDuJPvc,2322
 job_shop_lib/dispatching/feature_observers/_composite_feature_observer.py,sha256=tpvqTLIcNmbYROSFT62LiUZ_tI4fHWL_qCULKK43BU4,6429
-job_shop_lib/dispatching/feature_observers/_duration_observer.py,sha256=fbkUIVScF1iNjdVCYr1ImQm53TfahvVnGXhsRAsgdzY,4129
+job_shop_lib/dispatching/feature_observers/_dates_observer.py,sha256=oCk1XAo_2mrgD0ckHQLw3dD7DSQVVg7xBKn7D_u1Dvc,6083
+job_shop_lib/dispatching/feature_observers/_duration_observer.py,sha256=pBsJjT-1pbSi32hoLppoqXCftBvJPSh7r7tl3m7etAQ,4225
 job_shop_lib/dispatching/feature_observers/_earliest_start_time_observer.py,sha256=AQIjVp7VRDnb5GuYZlLUwk-xiXSqbsxJW-Ji7NjLoAw,11452
 job_shop_lib/dispatching/feature_observers/_factory.py,sha256=NyXYK5A1hXsYEeEqngwVRNAFkevY95DglheeqyfFv8s,3217
 job_shop_lib/dispatching/feature_observers/_feature_observer.py,sha256=qbgtMUicQ5FWS-Ql4Izjsj4QrevfOGlWzoJ0JlVSLH0,8668
@@ -29,17 +30,17 @@ job_shop_lib/dispatching/feature_observers/_is_ready_observer.py,sha256=wy_pA-1w
 job_shop_lib/dispatching/feature_observers/_is_scheduled_observer.py,sha256=OcuMUB9_By6ZMtX-1_3z-xaxGbP85a5Zv0ywAv7XxWQ,1491
 job_shop_lib/dispatching/feature_observers/_position_in_job_observer.py,sha256=WRknpQBKXs6h6cXLFJW7ZCvjtU8CPL-iXXNPw3g-mLE,1303
 job_shop_lib/dispatching/feature_observers/_remaining_operations_observer.py,sha256=5V87lCrJUabEe8AkTGXPu5yS8OGxeN8L3-xNyHmdmLs,1441
-job_shop_lib/dispatching/rules/__init__.py,sha256=0Nn9FBVmxVYeDeLsd7g7WkmKFBYJqOIDzArbqsC7FAI,2187
-job_shop_lib/dispatching/rules/_dispatching_rule_factory.py,sha256=5fNpv90fAoR6rcE6NeJOWiB7ir-FVnoONIhHtKJ9H0E,2904
+job_shop_lib/dispatching/rules/__init__.py,sha256=u1XCRU4tVXJ2rdxXQabPIBaRly0PbBmBu1QcEKx9Z_Y,2396
+job_shop_lib/dispatching/rules/_dispatching_rule_factory.py,sha256=iwqGHtroZAuE90fKOAe79reHlJ8gCnJzMjCkI0lucMg,3101
 job_shop_lib/dispatching/rules/_dispatching_rule_solver.py,sha256=1_canC1lXZATrQCZaHOY3JOLmTuT6U0Z_QWzgTOLwqI,5917
-job_shop_lib/dispatching/rules/_dispatching_rules_functions.py,sha256=Yk40aKePBHHiMO6aTFeyJd1-khsDPhqit2WCOaByCfw,10998
+job_shop_lib/dispatching/rules/_dispatching_rules_functions.py,sha256=c-T6jUXZ2wjkmENBlDfNyWUA4T3inGll1E0jqAn6wd8,12052
 job_shop_lib/dispatching/rules/_machine_chooser_factory.py,sha256=CJ74ujgWXgG8cuULWY6VJkD_b3arTcOjTNLZJTAf8xE,2346
 job_shop_lib/dispatching/rules/_utils.py,sha256=m5qw4qyfaIvVrkmv51nuhreizr98-cg8AJKt2VTd48w,4603
 job_shop_lib/exceptions.py,sha256=ARzpoZJCvRIvOesCiqqFSRxkv6w9WwEXx0aBP-l2IKA,1597
 job_shop_lib/generation/__init__.py,sha256=QaWwuBfBNnOiG0OPiP_CV_flBu9dX7r2o_HwL47tREM,822
 job_shop_lib/generation/_general_instance_generator.py,sha256=b_tnyP4H_buoN7b6lKQRLvDkeZDdys0mpqS3thB5-SQ,6544
 job_shop_lib/generation/_instance_generator.py,sha256=doN6WySyI0k7wz3aKy_e6hj6t7WV3dNzve3YmTFShas,4584
-job_shop_lib/generation/_utils.py,sha256=TYBGt4Zjw94l6ukIjXBVAK3lmrrZXdyzyq_r1DMlL-E,3986
+job_shop_lib/generation/_utils.py,sha256=b3SVU5DY3-VHXX2yrOwM7ABDSexiSFSRbo1d5QjRfoI,3972
 job_shop_lib/graphs/__init__.py,sha256=wlYIiXTuZRE6Kx3K0RpPUoZikzoegBuN2hcdqMODtGk,2433
 job_shop_lib/graphs/_build_disjunctive_graph.py,sha256=UbUYdeQaaeEqLchcKJGHEFGl4wElfGLb1o_R-u8wqnA,5120
 job_shop_lib/graphs/_build_resource_task_graphs.py,sha256=vIy_EkQjgQAd5YyJxKAuGf7CLTjgCfhz-fYrObF4DTU,6962
@@ -67,7 +68,7 @@ job_shop_lib/visualization/gantt/_plot_gantt_chart.py,sha256=_4UGUTRuIw0tLzsJD9G
 job_shop_lib/visualization/graphs/__init__.py,sha256=HUWzfgQLeklNROtjnxeJX_FIySo_baTXO6klx0zUVpQ,630
 job_shop_lib/visualization/graphs/_plot_disjunctive_graph.py,sha256=L9_ZGgvCFpGc2rTOdZESdtydFQqShjqedimIOhqZx6Y,16209
 job_shop_lib/visualization/graphs/_plot_resource_task_graph.py,sha256=nkkdZ-9_OBevw72Frecwzv1y3WyhGZ9r9lz0y9MXvZ8,13192
-job_shop_lib-1.3.0.dist-info/LICENSE,sha256=9mggivMGd5taAu3xbmBway-VQZMBzurBGHofFopvUsQ,1069
-job_shop_lib-1.3.0.dist-info/METADATA,sha256=oVgHOo9l8-crgD3w_uiR5zU6B0m9gxRAI0IPu7pSnpU,19130
-job_shop_lib-1.3.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-job_shop_lib-1.3.0.dist-info/RECORD,,
+job_shop_lib-1.5.0.dist-info/LICENSE,sha256=9mggivMGd5taAu3xbmBway-VQZMBzurBGHofFopvUsQ,1069
+job_shop_lib-1.5.0.dist-info/METADATA,sha256=ggq_EHjUpRr9jX_67Sc3Fhj7sFlOqOL1tWzqRY-4xzY,19130
+job_shop_lib-1.5.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+job_shop_lib-1.5.0.dist-info/RECORD,,