job-shop-lib 1.0.3__py3-none-any.whl → 1.1.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.0.3"
+__version__ = "1.1.0"
 
 __all__ = [
     "Operation",

job_shop_lib/_schedule.py

@@ -121,7 +121,23 @@ class Schedule:
         job_sequences: list[list[int]],
         metadata: dict[str, Any] | None = None,
     ) -> Schedule:
-        """Creates a schedule from a dictionary representation."""
+        """Creates a schedule from a dictionary representation.
+
+        Args:
+            instance:
+                The instance to create the schedule for. Can be a dictionary
+                representation of a :class:`JobShopInstance` or a
+                :class:`JobShopInstance` object.
+            job_sequences:
+                A list of lists of job ids. Each list of job ids represents the
+                order of operations on the machine. The machine that the list
+                corresponds to is determined by the index of the list.
+            metadata:
+                A dictionary with additional information about the schedule.
+
+        Returns:
+            A :class:`Schedule` object with the given job sequences.
+        """
         if isinstance(instance, dict):
             instance = JobShopInstance.from_matrices(**instance)
         schedule = Schedule.from_job_sequences(instance, job_sequences)
@@ -157,7 +173,7 @@ class Schedule:
         dispatcher.reset()
         raw_solution_deques = [deque(job_ids) for job_ids in job_sequences]
 
-        while not dispatcher.schedule.is_complete():
+        while any(job_seq for job_seq in raw_solution_deques):
             at_least_one_operation_scheduled = False
             for machine_id, job_ids in enumerate(raw_solution_deques):
                 if not job_ids:

job_shop_lib/dispatching/__init__.py

@@ -18,13 +18,24 @@ Problem step-by-step.
     filter_non_idle_machines
     filter_non_immediate_operations
     create_composite_operation_filter
+    StartTimeCalculator
+    no_setup_time_calculator
+    get_machine_dependent_setup_time_calculator
+    get_matrix_setup_time_calculator
+    get_breakdown_calculator
+    get_job_dependent_setup_calculator
 
 Dispatching refers to the decision-making process of selecting which job
 should be processed next on a particular machine when that machine becomes
 available.
 """
 
-from ._dispatcher import Dispatcher, DispatcherObserver
+from ._dispatcher import (
+    Dispatcher,
+    DispatcherObserver,
+    StartTimeCalculator,
+    no_setup_time_calculator,
+)
 from ._history_observer import (
     HistoryObserver,
 )
@@ -37,6 +48,12 @@ from ._ready_operation_filters import (
     filter_non_idle_machines,
     filter_non_immediate_operations,
 )
+from ._start_time_calculators import (
+    get_machine_dependent_setup_time_calculator,
+    get_breakdown_calculator,
+    get_job_dependent_setup_calculator,
+    get_matrix_setup_time_calculator,
+)
 from ._dispatcher_observer_config import DispatcherObserverConfig
 from ._factories import (
     ReadyOperationsFilterType,
@@ -48,6 +65,7 @@ from ._factories import (
 __all__ = [
     "Dispatcher",
     "DispatcherObserver",
+    "StartTimeCalculator",
     "HistoryObserver",
     "UnscheduledOperationsObserver",
     "OptimalOperationsObserver",
@@ -60,4 +78,10 @@ __all__ = [
     "filter_non_idle_machines",
     "filter_non_immediate_operations",
     "create_composite_operation_filter",
+    "no_setup_time_calculator",
+    "get_machine_dependent_setup_time_calculator",
+    "StartTimeCalculator",
+    "get_matrix_setup_time_calculator",
+    "get_breakdown_calculator",
+    "get_job_dependent_setup_calculator",
 ]

job_shop_lib/dispatching/_dispatcher.py

@@ -16,6 +16,34 @@ from job_shop_lib import (
 from job_shop_lib.exceptions import ValidationError
 
 
+# Type alias for start time calculator callable
+StartTimeCalculator = Callable[["Dispatcher", Operation, int], int]
+
+
+def no_setup_time_calculator(
+    dispatcher: Dispatcher, operation: Operation, machine_id: int
+) -> 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.
+
+    Args:
+        dispatcher: The dispatcher instance.
+        operation: The operation to be scheduled.
+        machine_id: The id of the machine on which the operation is to be
+            scheduled.
+
+    Returns:
+        The start time for the operation on the given machine.
+    """
+    return max(
+        dispatcher.machine_next_available_time[machine_id],
+        dispatcher.job_next_available_time[operation.job_id],
+    )
+
+
 # Added here to avoid circular imports
 class DispatcherObserver(abc.ABC):
     """Abstract class that allows objects to observe and respond to changes
@@ -192,6 +220,14 @@ class Dispatcher:
             list of operations as input and return a list of operations
             that are ready to be scheduled. If ``None``, no filtering is
             done.
+        start_time_calculator:
+            A function that calculates the start time for a given operation
+            on a given machine. The function should take a dispatcher, an
+            operation and a machine id as input and return the start time for
+            the operation. Defaults to the standard calculation which is the
+            maximum of the machine's next available time and the job's next
+            available time. This allows for implementing context-dependent
+            setup times, downtime, and machine breakdowns.
     """
 
     __slots__ = {
@@ -204,6 +240,10 @@ class Dispatcher:
             "A function that filters out operations that are not ready to be "
             "scheduled."
         ),
+        "start_time_calculator": (
+            "A function that calculates the start time for a given operation "
+            "on a given machine."
+        ),
         "subscribers": "A list of observers subscribed to the dispatcher.",
         "_cache": "A dictionary to cache the results of the cached methods.",
     }
@@ -214,11 +254,15 @@ class Dispatcher:
         ready_operations_filter: (
             Callable[[Dispatcher, list[Operation]], list[Operation]] | None
         ) = None,
+        start_time_calculator: StartTimeCalculator = (
+            no_setup_time_calculator
+        ),
     ) -> None:
 
         self.instance = instance
         self.schedule = Schedule(self.instance)
         self.ready_operations_filter = ready_operations_filter
+        self.start_time_calculator = start_time_calculator
         self.subscribers: list[DispatcherObserver] = []
 
         self._machine_next_available_time = [0] * self.instance.num_machines
@@ -327,7 +371,8 @@ class Dispatcher:
         """Computes the start time for the given operation on the given
         machine.
 
-        The start time is the maximum of the next available time for the
+        Uses the configured start time calculator to compute the start time.
+        By default, this is the maximum of the next available time for the
         machine and the next available time for the job to which the
         operation belongs.
 
@@ -338,10 +383,7 @@ class Dispatcher:
                 The id of the machine on which the operation is to be
                 scheduled.
         """
-        return max(
-            self._machine_next_available_time[machine_id],
-            self._job_next_available_time[operation.job_id],
-        )
+        return self.start_time_calculator(self, operation, machine_id)
 
     def _update_tracking_attributes(
         self, scheduled_operation: ScheduledOperation

job_shop_lib/dispatching/_start_time_calculators.py

@@ -0,0 +1,195 @@
+"""Predefined start time calculator functions for the Dispatcher class.
+
+This module contains commonly used start time calculators that can be used
+with the Dispatcher class to implement different scheduling behaviors.
+"""
+
+from collections.abc import Sequence
+import numpy as np
+from numpy.typing import NDArray
+
+from job_shop_lib import Operation
+from job_shop_lib.dispatching import (
+    Dispatcher,
+    no_setup_time_calculator,
+    StartTimeCalculator,
+)
+
+
+def get_matrix_setup_time_calculator(
+    setup_times: Sequence[Sequence[int]] | NDArray[np.integer],
+) -> StartTimeCalculator:
+    """Returns a start time calculator that adds setup times based on a
+    matrix of setup times.
+
+    Args:
+        setup_times:
+            A 2D matrix where setup_times[i][j] is the setuptime
+            for switching from operation ``i`` to operation ``j``. Here,
+            ``i`` and ``j`` are operation's IDs.
+    Returns:
+        A start time calculator function that adds setup times based on the
+        matrix.
+
+    Example:
+        >>> setup_calc = get_matrix_setup_time_calculator([[0, 2], [1, 0]])
+        >>> dispatcher = Dispatcher(instance, start_time_calculator=setup_calc)
+    """
+
+    def calculator(
+        dispatcher: Dispatcher, operation: Operation, machine_id: int
+    ) -> int:
+        default_start = no_setup_time_calculator(
+            dispatcher, operation, machine_id
+        )
+        machine_schedule = dispatcher.schedule.schedule[machine_id]
+        if not machine_schedule:
+            return default_start
+
+        last_operation = machine_schedule[-1].operation
+        setup_time = setup_times[last_operation.operation_id][
+            operation.operation_id
+        ]
+
+        return default_start + setup_time
+
+    return calculator
+
+
+def get_machine_dependent_setup_time_calculator(
+    setup_times: dict[int, int], default: int = 0
+):
+    """Returns a start time calculator that adds setup times based on
+    machine IDs.
+
+    Args:
+        setup_times:
+            Dictionary mapping machine_id to setup time in time units.
+        default:
+            Default setup time to use if a machine_id is not found
+            in the setup_times dictionary.
+
+    Returns:
+        A start time calculator function that adds setup times.
+
+    Example:
+        >>> setup_calc = get_machine_dependent_setup_time_calculator(
+        ...     {0: 2, 1: 1, 2: 3}
+        ... )
+        >>> dispatcher = Dispatcher(instance, start_time_calculator=setup_calc)
+    """
+
+    def calculator(
+        dispatcher: Dispatcher, operation: Operation, machine_id: int
+    ) -> int:
+        default_start = no_setup_time_calculator(
+            dispatcher, operation, machine_id
+        )
+        setup_time = setup_times.get(machine_id, default)
+        return default_start + setup_time
+
+    return calculator
+
+
+def get_breakdown_calculator(breakdowns: dict[int, list[tuple[int, int]]]):
+    """Returns a start time calculator that accounts for machine breakdowns.
+
+    This calculator adjusts the start time of an operation based on
+    when the machine is expected to be down due to breakdowns, maintenance,
+    holidays, etc.
+
+    Args:
+        breakdowns: Dictionary mapping machine_id to list of
+                   (start_time, duration) tuples representing when
+                   the machine breaks down.
+
+    Returns:
+        A start time calculator function that accounts for breakdowns.
+
+    Example:
+        >>> breakdown_calc = breakdown_calculator({0: [(5, 3)], 1: [(8, 2)]})
+        >>> dispatcher = Dispatcher(instance,
+        ...                        start_time_calculator=breakdown_calc)
+    """
+
+    def calculator(
+        dispatcher: Dispatcher, operation: Operation, machine_id: int
+    ) -> int:
+        default_start = no_setup_time_calculator(
+            dispatcher, operation, machine_id
+        )
+        if machine_id not in breakdowns:
+            return default_start
+
+        start_time = default_start
+        for breakdown_start, breakdown_duration in breakdowns[machine_id]:
+            breakdown_end = breakdown_start + breakdown_duration
+
+            start_during_breakdown = (
+                breakdown_start <= start_time < breakdown_end
+            )
+            completion_time = start_time + operation.duration
+            run_into_breakdown = start_time < breakdown_start < completion_time
+            if start_during_breakdown or run_into_breakdown:
+                start_time = breakdown_end
+
+        return start_time
+
+    return calculator
+
+
+def get_job_dependent_setup_calculator(
+    same_job_setup: int = 0,
+    different_job_setup: int = 4,
+    initial_setup: int = 0,
+):
+    """Factory for a calculator with sequence-dependent setup times.
+
+    This calculator determines setup time based on whether the current
+    operation's job matches the job of the previously processed operation
+    on the same machine.
+
+    Args:
+        same_job_setup:
+            Setup time when the previous operation on the
+            machine was from the same job.
+        different_job_setup:
+            Setup time when the previous operation
+            on the machine was from a different job.
+        initial_setup:
+            Setup time for the first operation on a machine
+            or if the machine is currently idle.
+
+    Returns:
+        A start time calculator function that applies
+        sequence-dependent setup times.
+
+    Example:
+        >>> seq_dep_calc = sequence_dependent_setup_calculator(
+        ...     same_job_setup=1, different_job_setup=4, initial_setup=1
+        ... )
+        >>> # Assuming 'instance' is a JobShopInstance
+        >>> dispatcher = Dispatcher(
+        ...     instance, start_time_calculator=seq_dep_calc
+        ... )
+    """
+
+    def calculator(
+        dispatcher: Dispatcher, operation: Operation, machine_id: int
+    ) -> int:
+        default_start = no_setup_time_calculator(
+            dispatcher, operation, machine_id
+        )
+        machine_schedule = dispatcher.schedule.schedule[machine_id]
+        if not machine_schedule:
+            setup_time = initial_setup
+        else:
+            last_operation_on_machine = machine_schedule[-1].operation
+            if last_operation_on_machine.job_id == operation.job_id:
+                setup_time = same_job_setup
+            else:
+                setup_time = different_job_setup
+
+        return default_start + setup_time
+
+    return calculator

{job_shop_lib-1.0.3.dist-info → job_shop_lib-1.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: job-shop-lib
-Version: 1.0.3
+Version: 1.1.0
 Summary: An easy-to-use and modular Python library for the Job Shop Scheduling Problem (JSSP)
 License: MIT
 Author: Pabloo22
@@ -50,9 +50,7 @@ See [this](https://colab.research.google.com/drive/1XV_Rvq1F2ns6DFG8uNj66q_rcoww
 
 <!-- start installation -->
 
-JobShopLib is distributed on [PyPI](https://pypi.org/project/job-shop-lib/) and it supports Python 3.10+.
-
-You can install the latest stable version using `pip`:
+JobShopLib is distributed on [PyPI](https://pypi.org/project/job-shop-lib/). You can install the latest stable version using `pip`:
 
 ```bash
 pip install job-shop-lib
@@ -68,7 +66,7 @@ pip install job-shop-lib
 
 - **Benchmark Instances**: Load well-known benchmark instances directly from the library without manual downloading. See [Load Benchmark Instances](https://github.com/Pabloo22/job_shop_lib/blob/main/docs/source/examples/05-Load-Benchmark-Instances.ipynb).
 
-- **Random Instance Generation**: Create random instances with customizable sizes and properties or augment existing ones. See [`generation`](job_shop_lib/generation) package.
+- **Random Instance Generation**: Create random instances with customizable sizes and properties. See [`generation`](job_shop_lib/generation) package.
 
 - **Multiple Solvers**:
   - **Constraint Programming Solver**: OR-Tools' CP-SAT solver. See [Solving the Problem](https://github.com/Pabloo22/job_shop_lib/blob/main/docs/source/tutorial/02-Solving-the-Problem.ipynb).
@@ -134,7 +132,7 @@ The contributions to this benchmark dataset are as follows:
 
 - `orb01-10`: by Applegate and Cook (1991).
 
-- `swb01-20`: by Storer et al. (1992).
+- `swv01-20`: by Storer et al. (1992).
 
 - `yn1-4`: by Yamada and Nakano (1992).
 

{job_shop_lib-1.0.3.dist-info → job_shop_lib-1.1.0.dist-info}/RECORD

@@ -1,21 +1,22 @@
-job_shop_lib/__init__.py,sha256=LO5qbdFVxGXYyTatsF_9qx-gZ53kyr2x5MUwaMqaLNw,639
+job_shop_lib/__init__.py,sha256=GsvMMVRVHzH1Qy7eKfNKp87NNRO8TBE-asEgZF7TIaA,639
 job_shop_lib/_base_solver.py,sha256=p17XmtufNc9Y481cqZUT45pEkUmmW1HWG53dfhIBJH8,1363
 job_shop_lib/_job_shop_instance.py,sha256=RWibh5_lVTHj0DEkMw94O4jYZhwRReYYpVVIbT0cYtQ,18353
 job_shop_lib/_operation.py,sha256=lwCjgXwWlgESFuV3Yh4SCVofPGCd3hJU4vnK7peREac,4235
-job_shop_lib/_schedule.py,sha256=QQ7orbpd00pTjJvsh8bNuRSEFJLst8B8GaCSB8JPXTY,11251
+job_shop_lib/_schedule.py,sha256=pY02c-VF7cHxR29dFAktrn32mFi0cmRIcDAGsoekK8g,11941
 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=oMPeA2VHoYX1ZvmygQ8kYew40ITLAQATmM4OhgVFuXM,10482
-job_shop_lib/dispatching/__init__.py,sha256=dGctOuTVkj0eLfmRM1Us5x7ZtnUvtJC_M7lnZpZrxo0,1835
-job_shop_lib/dispatching/_dispatcher.py,sha256=6LmobUuE8-tPSAmfsoSiOjarPk5AIcaJY5it0Jxr2Eo,22006
+job_shop_lib/dispatching/__init__.py,sha256=eyiCpCWIsx3LDoSOtPImjYAkI6R8t93kz56hM03WODE,2558
+job_shop_lib/dispatching/_dispatcher.py,sha256=5zCTBIl96dcqAmdwp_1I_4V9ox2X4zMz5-ZHwpMvWGU,23765
 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=Tdclcvt_BK28eYxTzgF7Kiz1IBZAFpXRay0U62-VDHA,4211
 job_shop_lib/dispatching/_ready_operation_filters.py,sha256=brhmhoyyoZ98wAEEfneZC-CD-aw9SerZHGMB1DpK8HY,5749
+job_shop_lib/dispatching/_start_time_calculators.py,sha256=sEtInDnFW9gsKDUEDUGQBaIjDWgCkFYvBca46j8XYfE,6408
 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/_composite_feature_observer.py,sha256=FPVnrX9ySS9Bg7OpIP9FPdUeJ25Jtti3q3JvpkkHvqk,7915
@@ -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=YyNEKgg1ol34JYu8Ej1kKonsuFu7zDav4uuUzU_FS4Q,15905
 job_shop_lib/visualization/graphs/_plot_resource_task_graph.py,sha256=Sp1aokyM_8QZb39QCLrjQECcbDHkdcYw7wMZILWxN9o,13191
-job_shop_lib-1.0.3.dist-info/LICENSE,sha256=9mggivMGd5taAu3xbmBway-VQZMBzurBGHofFopvUsQ,1069
-job_shop_lib-1.0.3.dist-info/METADATA,sha256=nPyfAr6Aa-IxK-5XR3c_MtA9DLmv8Bsqp94Zb5ZnPIg,16460
-job_shop_lib-1.0.3.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-job_shop_lib-1.0.3.dist-info/RECORD,,
+job_shop_lib-1.1.0.dist-info/LICENSE,sha256=9mggivMGd5taAu3xbmBway-VQZMBzurBGHofFopvUsQ,1069
+job_shop_lib-1.1.0.dist-info/METADATA,sha256=VOiEg8x4xozLpf04qjhX0NBEsnDrbzEUPtUi89GqE10,16405
+job_shop_lib-1.1.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+job_shop_lib-1.1.0.dist-info/RECORD,,