job-shop-lib 1.6.1__py3-none-any.whl → 1.7.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.6.1"
+__version__ = "1.7.0"
 
 __all__ = [
     "Operation",

job_shop_lib/_job_shop_instance.py

@@ -40,12 +40,12 @@ class JobShopInstance:
         num_machines
         num_operations
         is_flexible
-        durations_matrix
+        duration_matrix
         machines_matrix
         release_dates_matrix
         deadlines_matrix
         due_dates_matrix
-        durations_matrix_array
+        duration_matrix_array
         machines_matrix_array
         operations_by_machine
         max_duration
@@ -216,7 +216,7 @@ class JobShopInstance:
 
                 {
                     "name": self.name,
-                    "duration_matrix": self.durations_matrix,
+                    "duration_matrix": self.duration_matrix,
                     "machines_matrix": self.machines_matrix,
                     "metadata": self.metadata,
                     # Optionally (if the instance has them):
@@ -227,7 +227,7 @@ class JobShopInstance:
         """
         data = {
             "name": self.name,
-            "duration_matrix": self.durations_matrix,
+            "duration_matrix": self.duration_matrix,
             "machines_matrix": self.machines_matrix,
             "metadata": self.metadata,
         }
@@ -374,6 +374,22 @@ class JobShopInstance:
 
     @functools.cached_property
     def durations_matrix(self) -> list[list[int]]:
+        """Another name for `duration_matrix` attribute, kept for
+        backward compatibility.
+
+        It may be removed in future versions.
+        """
+        warnings.warn(
+            "`duration_matrix` attribute is deprecated and will be "
+            "removed in future versions. Please use `duration_matrix` "
+            "property instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self.duration_matrix
+
+    @functools.cached_property
+    def duration_matrix(self) -> list[list[int]]:
         """Returns the duration matrix of the instance.
 
         The duration of the operation with ``job_id`` i and ``position_in_job``
@@ -452,7 +468,23 @@ class JobShopInstance:
         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)
+        warnings.warn(
+            "`durations_matrix_array` attribute is deprecated and will be "
+            "removed in future versions. Please use `duration_matrix_array` "
+            "property instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self.duration_matrix_array
+
+    @property
+    def duration_matrix_array(self) -> NDArray[np.float32]:
+        """Returns the duration 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.
+        """
+        return self._fill_matrix_with_nans_2d(self.duration_matrix)
 
     @functools.cached_property
     def release_dates_matrix_array(self) -> NDArray[np.float32]:

job_shop_lib/benchmarking/__init__.py

@@ -6,6 +6,7 @@
     load_all_benchmark_instances
     load_benchmark_instance
     load_benchmark_json
+    load_benchmark_group
 
 You can load a benchmark instance from the library:
 
@@ -93,10 +94,12 @@ from job_shop_lib.benchmarking._load_benchmark import (
     load_all_benchmark_instances,
     load_benchmark_instance,
     load_benchmark_json,
+    load_benchmark_group,
 )
 
 __all__ = [
     "load_all_benchmark_instances",
     "load_benchmark_instance",
     "load_benchmark_json",
+    "load_benchmark_group",
 ]

job_shop_lib/benchmarking/_load_benchmark.py

@@ -86,3 +86,28 @@ def load_benchmark_json() -> dict[str, dict[str, Any]]:
 
     with benchmark_file.open("r", encoding="utf-8") as f:
         return json.load(f)
+
+
+@functools.cache
+def load_benchmark_group(group_prefix: str) -> list[JobShopInstance]:
+    """Loads a group of benchmark instances whose names start with the given
+    prefix.
+
+    Args:
+        group_prefix:
+            The prefix of the benchmark instances to load. For example,
+            if the prefix is "la", all instances whose names start with "la"
+            (e.g., "la01-40", "la02-40", etc.) will be loaded.
+
+    Returns:
+        A list of :class:`JobShopInstance` objects whose names start with
+        the given prefix.
+
+    .. versionadded:: 1.7.0
+    """
+    all_instances = load_all_benchmark_instances()
+    return [
+        instance
+        for name, instance in all_instances.items()
+        if name.startswith(group_prefix)
+    ]

job_shop_lib/dispatching/feature_observers/_duration_observer.py

@@ -58,7 +58,7 @@ class DurationObserver(FeatureObserver):
             mapping[feature_type](scheduled_operation)
 
     def _initialize_operation_durations(self):
-        duration_matrix = self.dispatcher.instance.durations_matrix_array
+        duration_matrix = self.dispatcher.instance.duration_matrix_array
         operation_durations = np.array(duration_matrix).reshape(-1, 1)
         # Drop the NaN values
         operation_durations = operation_durations[

job_shop_lib/dispatching/feature_observers/_earliest_start_time_observer.py

@@ -80,7 +80,7 @@ class EarliestStartTimeObserver(FeatureObserver):
 
         # Earliest start times initialization
         # -------------------------------
-        squared_duration_matrix = dispatcher.instance.durations_matrix_array
+        squared_duration_matrix = dispatcher.instance.duration_matrix_array
         self.earliest_start_times: NDArray[np.float32] = np.hstack(
             (
                 np.zeros((squared_duration_matrix.shape[0], 1), dtype=float),

job_shop_lib/generation/__init__.py

@@ -5,16 +5,46 @@
 
     InstanceGenerator
     GeneralInstanceGenerator
-    generate_duration_matrix
+    modular_instance_generator
     generate_machine_matrix_with_recirculation
     generate_machine_matrix_without_recirculation
+    generate_duration_matrix
+    range_size_selector
+    choice_size_selector
+    get_default_machine_matrix_creator
+    get_default_duration_matrix_creator
+    ReleaseDateStrategy
+    create_release_dates_matrix
+    get_independent_release_date_strategy
+    get_cumulative_release_date_strategy
+    get_mixed_release_date_strategy
+    compute_horizon_proxy
 
 """
 
-from job_shop_lib.generation._utils import (
-    generate_duration_matrix,
+from job_shop_lib.generation._size_selectors import (
+    range_size_selector,
+    choice_size_selector,
+)
+from job_shop_lib.generation._machine_matrix import (
     generate_machine_matrix_with_recirculation,
     generate_machine_matrix_without_recirculation,
+    get_default_machine_matrix_creator,
+)
+from job_shop_lib.generation._duration_matrix import (
+    get_default_duration_matrix_creator,
+    generate_duration_matrix,
+)
+from job_shop_lib.generation._release_date_matrix import (
+    ReleaseDateStrategy,
+    create_release_dates_matrix,
+    get_independent_release_date_strategy,
+    get_cumulative_release_date_strategy,
+    get_mixed_release_date_strategy,
+    compute_horizon_proxy,
+)
+from job_shop_lib.generation._modular_instance_generator import (
+    modular_instance_generator,
 )
 from job_shop_lib.generation._instance_generator import InstanceGenerator
 from job_shop_lib.generation._general_instance_generator import (
@@ -27,4 +57,15 @@ __all__ = [
     "generate_duration_matrix",
     "generate_machine_matrix_with_recirculation",
     "generate_machine_matrix_without_recirculation",
+    "modular_instance_generator",
+    "range_size_selector",
+    "choice_size_selector",
+    "get_default_machine_matrix_creator",
+    "get_default_duration_matrix_creator",
+    "ReleaseDateStrategy",
+    "create_release_dates_matrix",
+    "get_independent_release_date_strategy",
+    "get_cumulative_release_date_strategy",
+    "get_mixed_release_date_strategy",
+    "compute_horizon_proxy",
 ]

job_shop_lib/generation/_duration_matrix.py

@@ -0,0 +1,83 @@
+from collections.abc import Callable
+import random
+
+import numpy as np
+from numpy.typing import NDArray
+
+from job_shop_lib.exceptions import ValidationError
+
+
+def get_default_duration_matrix_creator(
+    duration_range: tuple[int, int] = (1, 99),
+) -> Callable[
+    [list[list[list[int]]] | list[list[int]], random.Random],
+    list[list[int]],
+]:
+    """Creates a duration matrix generator function.
+
+    Internally, it wraps :func:`generate_duration_matrix`.
+
+    .. note::
+
+       This function assumes that the machine matrix has the shape (num_jobs,
+       num_machines).
+
+    Args:
+        duration_range:
+            A tuple specifying the inclusive range for operation durations.
+
+    Returns:
+        A callable that generates a duration matrix of shape (num_jobs,
+        num_machines) when called with a machine matrix and a
+        `random.Random` instance.
+    """
+
+    def duration_matrix_creator(
+        machine_matrix: list[list[list[int]]] | list[list[int]],
+        rng: random.Random,
+    ) -> list[list[int]]:
+        seed_for_np = rng.randint(0, 2**16 - 1)
+        numpy_rng = np.random.default_rng(seed_for_np)
+        num_jobs = len(machine_matrix)
+        num_machines = len(machine_matrix[0])
+        return generate_duration_matrix(
+            num_jobs, num_machines, duration_range, numpy_rng
+        ).tolist()
+
+    return duration_matrix_creator
+
+
+def generate_duration_matrix(
+    num_jobs: int,
+    num_machines: int,
+    duration_range: tuple[int, int],
+    rng: np.random.Generator | None = None,
+) -> NDArray[np.int32]:
+    """Generates a duration matrix.
+
+    Args:
+        num_jobs: The number of jobs.
+        num_machines: The number of machines.
+        duration_range: The range of the duration values.
+        rng: A numpy random number generator.
+
+    Returns:
+        A duration matrix with shape (num_jobs, num_machines).
+    """
+    rng = rng or np.random.default_rng()
+    if duration_range[0] > duration_range[1]:
+        raise ValidationError(
+            "The lower bound of the duration range must be less than or equal "
+            "to the upper bound."
+        )
+    if num_jobs <= 0:
+        raise ValidationError("The number of jobs must be greater than 0.")
+    if num_machines <= 0:
+        raise ValidationError("The number of machines must be greater than 0.")
+
+    return rng.integers(
+        duration_range[0],
+        duration_range[1] + 1,
+        size=(num_jobs, num_machines),
+        dtype=np.int32,
+    )

job_shop_lib/generation/_instance_generator.py

@@ -13,13 +13,13 @@ class InstanceGenerator(ABC):
     """Common interface for all generators.
 
     The class supports both single instance generation and iteration over
-    multiple instances, controlled by the `iteration_limit` parameter. It
-    implements the iterator protocol, allowing it to be used in a `for` loop.
+    multiple instances, controlled by the ``iteration_limit`` parameter. It
+    implements the iterator protocol, allowing it to be used in a ``for`` loop.
 
     Note:
         When used as an iterator, the generator will produce instances until it
-        reaches the specified `iteration_limit`. If `iteration_limit` is None,
-        it will continue indefinitely.
+        reaches the specified ``iteration_limit``. If ``iteration_limit`` is
+        ``None``, it will continue indefinitely.
 
     Attributes:
         num_jobs_range:
@@ -84,9 +84,11 @@ class InstanceGenerator(ABC):
         """Generates a single job shop instance
 
         Args:
-            num_jobs: The number of jobs to generate. If None, a random value
+            num_jobs:
+                The number of jobs to generate. If None, a random value
                 within the specified range will be used.
-            num_machines: The number of machines to generate. If None, a random
+            num_machines:
+                The number of machines to generate. If None, a random
                 value within the specified range will be used.
         """
 

job_shop_lib/generation/{_utils.py → _machine_matrix.py}

@@ -1,43 +1,62 @@
+from collections.abc import Callable
+import random
+
 import numpy as np
 from numpy.typing import NDArray
 
 from job_shop_lib.exceptions import ValidationError
 
 
-def generate_duration_matrix(
-    num_jobs: int,
-    num_machines: int,
-    duration_range: tuple[int, int],
-    rng: np.random.Generator | None = None,
-) -> NDArray[np.int32]:
-    """Generates a duration matrix.
+def get_default_machine_matrix_creator(
+    size_selector: Callable[[random.Random], tuple[int, int]] = (
+        lambda _: (10, 10)
+    ),
+    with_recirculation: bool = True,
+) -> Callable[[random.Random], list[list[list[int]]] | list[list[int]]]:
+    """Creates a machine matrix generator function.
+
+    Internally, it wraps either
+    :func:`generate_machine_matrix_with_recirculation`
+    or :func:`generate_machine_matrix_without_recirculation`
+    based on the `with_recirculation` parameter.
+
+    .. note::
+
+       The generated machine matrix will have the shape (num_jobs,
+       num_machines).
 
     Args:
-        num_jobs: The number of jobs.
-        num_machines: The number of machines.
-        duration_range: The range of the duration values.
-        rng: A numpy random number generator.
+        rng:
+            A random.Random instance.
+        size_selector:
+            A callable that takes a random.Random instance and returns a
+            tuple (num_jobs, num_machines).
+        with_recirculation:
+            If ``True``, generates a machine matrix with recirculation;
+            otherwise, without recirculation. Recirculation means that a job
+            can visit the same machine more than once.
 
     Returns:
-        A duration matrix with shape (num_jobs, num_machines).
+        A callable that generates a machine matrix when called with a
+        random.Random instance.
     """
-    rng = rng or np.random.default_rng()
-    if duration_range[0] > duration_range[1]:
-        raise ValidationError(
-            "The lower bound of the duration range must be less than or equal "
-            "to the upper bound."
-        )
-    if num_jobs <= 0:
-        raise ValidationError("The number of jobs must be greater than 0.")
-    if num_machines <= 0:
-        raise ValidationError("The number of machines must be greater than 0.")
 
-    return rng.integers(
-        duration_range[0],
-        duration_range[1] + 1,
-        size=(num_jobs, num_machines),
-        dtype=np.int32,
-    )
+    def generator(
+        rng: random.Random,
+    ) -> list[list[list[int]]]:
+        num_jobs, num_machines = size_selector(rng)
+        seed_for_np = rng.randint(0, 2**16 - 1)
+        numpy_rng = np.random.default_rng(seed_for_np)
+        if with_recirculation:
+            return generate_machine_matrix_with_recirculation(
+                num_jobs, num_machines, numpy_rng
+            ).tolist()
+
+        return generate_machine_matrix_without_recirculation(
+            num_jobs, num_machines, numpy_rng
+        ).tolist()
+
+    return generator
 
 
 def generate_machine_matrix_with_recirculation(
@@ -51,8 +70,8 @@ def generate_machine_matrix_with_recirculation(
         rng: A numpy random number generator.
 
     Returns:
-        A machine matrix with recirculation with shape (num_machines,
-        num_jobs).
+        A machine matrix with recirculation with shape (num_jobs,
+        num_machines).
     """
     rng = rng or np.random.default_rng()
     if num_jobs <= 0:
@@ -62,7 +81,7 @@ def generate_machine_matrix_with_recirculation(
     num_machines_is_correct = False
     while not num_machines_is_correct:
         machine_matrix: np.ndarray = rng.integers(
-            0, num_machines, size=(num_machines, num_jobs), dtype=np.int32
+            0, num_machines, size=(num_jobs, num_machines), dtype=np.int32
         )
         num_machines_is_correct = (
             len(np.unique(machine_matrix)) == num_machines
@@ -100,31 +119,3 @@ def generate_machine_matrix_without_recirculation(
     # Shuffle the columns:
     machine_matrix = np.apply_along_axis(rng.permutation, 1, machine_matrix)
     return machine_matrix
-
-
-if __name__ == "__main__":
-
-    NUM_JOBS = 3
-    NUM_MACHINES = 3
-    DURATION_RANGE = (1, 10)
-
-    duration_matrix = generate_duration_matrix(
-        num_jobs=NUM_JOBS,
-        num_machines=NUM_MACHINES,
-        duration_range=DURATION_RANGE,
-    )
-    print(duration_matrix)
-
-    machine_matrix_with_recirculation = (
-        generate_machine_matrix_with_recirculation(
-            num_jobs=NUM_JOBS, num_machines=NUM_MACHINES
-        )
-    )
-    print(machine_matrix_with_recirculation)
-
-    machine_matrix_without_recirculation = (
-        generate_machine_matrix_without_recirculation(
-            num_jobs=NUM_JOBS, num_machines=NUM_MACHINES
-        )
-    )
-    print(machine_matrix_without_recirculation)

job_shop_lib/generation/_modular_instance_generator.py

@@ -0,0 +1,116 @@
+from collections.abc import Callable
+from typing import Generator
+import random
+
+from job_shop_lib import JobShopInstance
+
+
+def modular_instance_generator(
+    machine_matrix_creator: Callable[
+        [random.Random], list[list[list[int]]] | list[list[int]]
+    ],
+    duration_matrix_creator: Callable[
+        [list[list[list[int]]] | list[list[int]], random.Random],
+        list[list[int]],
+    ],
+    *,
+    name_creator: Callable[[int], str] = lambda x: f"generated_instance_{x}",
+    release_dates_matrix_creator: (
+        Callable[
+            [list[list[int]], random.Random],
+            list[list[int]],
+        ]
+        | None
+    ) = None,
+    deadlines_matrix_creator: (
+        Callable[[list[list[int]], random.Random], list[list[int | None]]]
+        | None
+    ) = None,
+    due_dates_matrix_creator: (
+        Callable[[list[list[int]], random.Random], list[list[int | None]]]
+        | None
+    ) = None,
+    seed: int | None = None,
+) -> Generator[JobShopInstance, None, None]:
+    """Creates a generator function that produces job shop instances using
+    the provided components.
+
+    Args:
+        machine_matrix_creator:
+            A callable that creates a machine matrix.
+        duration_matrix_creator:
+            A callable that creates a duration matrix.
+        name_creator:
+            A callable that generates unique names for instances.
+        release_dates_matrix_creator:
+            An optional callable that generates release dates for jobs.
+        deadlines_matrix_creator:
+            An optional callable that generates deadlines for jobs.
+        due_dates_matrix_creator:
+            An optional callable that generates due dates for jobs.
+        seed:
+            An optional seed for random number generation.
+
+    Yields:
+        JobShopInstance:
+            A generated job shop instance created using the generated matrices.
+
+    Example:
+
+        >>> from job_shop_lib.generation import (
+        ...     get_default_machine_matrix_creator,
+        ...     get_default_duration_matrix_creator,
+        ...     modular_instance_generator,
+        ... )
+        >>> machine_matrix_gen = get_default_machine_matrix_creator(
+        ...     size_selector=lambda rng: (3, 3),
+        ...     with_recirculation=False,
+        ... )
+        >>> duration_matrix_gen = get_default_duration_matrix_creator(
+        ...     duration_range=(1, 10),
+        ... )
+        >>> instance_gen = modular_instance_generator(
+        ...     machine_matrix_creator=machine_matrix_gen,
+        ...     duration_matrix_creator=duration_matrix_gen,
+        ...     seed=42,
+        ... )
+        >>> instance = next(instance_gen)
+        >>> print(instance)
+        JobShopInstance(name=generated_instance_0, num_jobs=3, num_machines=3)
+        >>> print(instance.duration_matrix_array)
+        [[ 5.  6.  4.]
+         [ 5.  7. 10.]
+         [ 9.  9.  5.]]
+
+    .. versionadded:: 1.7.0
+    """
+    rng = random.Random(seed)
+    i = 0
+    while True:
+        machine_matrix = machine_matrix_creator(rng)
+        duration_matrix = duration_matrix_creator(machine_matrix, rng)
+        release_dates = (
+            release_dates_matrix_creator(duration_matrix, rng)
+            if release_dates_matrix_creator
+            else None
+        )
+        deadlines = (
+            deadlines_matrix_creator(duration_matrix, rng)
+            if deadlines_matrix_creator
+            else None
+        )
+        due_dates = (
+            due_dates_matrix_creator(duration_matrix, rng)
+            if due_dates_matrix_creator
+            else None
+        )
+        instance = JobShopInstance.from_matrices(
+            duration_matrix,
+            machine_matrix,
+            name=name_creator(i),
+            release_dates_matrix=release_dates,
+            deadlines_matrix=deadlines,
+            due_dates_matrix=due_dates,
+        )
+        i += 1
+        yield instance

job_shop_lib/generation/_release_date_matrix.py

@@ -0,0 +1,160 @@
+from typing import Sequence, Callable
+import random
+
+from job_shop_lib.exceptions import ValidationError
+
+
+ReleaseDateStrategy = Callable[[random.Random, int], int]
+
+
+def create_release_dates_matrix(
+    duration_matrix: list[list[int]],
+    strategy: ReleaseDateStrategy | None = None,
+    rng: random.Random | None = None,
+) -> list[list[int]]:
+    """Generate per-operation release dates for ragged job durations.
+
+    Args:
+        duration_matrix:
+            Ragged list of per-job operation durations.
+        strategy:
+            Callable implementing the release date policy. If ``None``
+            a default mixed strategy (alpha=0.7, beta=0.3) is built using the
+            computed horizon proxy.
+        rng:
+            Optional numpy random generator (one will be created if omitted).
+
+    Returns:
+        A ragged list mirroring ``duration_matrix`` structure with per-
+        operation release dates.
+
+    .. versionadded:: 1.7.0
+    """
+    rng = rng or random.Random()
+
+    num_jobs = len(duration_matrix)
+    if num_jobs == 0:
+        return []
+
+    if strategy is None:
+        horizon_proxy = compute_horizon_proxy(duration_matrix)
+        strategy = get_mixed_release_date_strategy(0.7, 0.3, horizon_proxy)
+
+    release_dates_matrix: list[list[int]] = []
+    for job_durations in duration_matrix:
+        job_release_dates: list[int] = []
+        cumulative_previous_duration = 0
+        for duration_value in job_durations:
+            release_date_value = strategy(rng, cumulative_previous_duration)
+            job_release_dates.append(release_date_value)
+            cumulative_previous_duration += int(duration_value)
+        release_dates_matrix.append(job_release_dates)
+
+    return release_dates_matrix
+
+
+def compute_horizon_proxy(duration_matrix: Sequence[Sequence[int]]) -> int:
+    """Compute the horizon proxy used previously for the mixed strategy.
+
+    It is defined as: round(total_duration / avg_operations_per_job)
+    with protections against division by zero.
+
+    Args:
+        duration_matrix:
+            Ragged list of per-job operation durations.
+
+    Returns:
+        The computed horizon proxy.
+
+    .. seealso::
+        :meth:`job_shop_lib.JobShopInstance.duration_matrix`
+
+    .. versionadded:: 1.7.0
+    """
+    num_jobs = len(duration_matrix)
+    if num_jobs == 0:
+        return 0
+    total_duration = sum(sum(job) for job in duration_matrix)
+    total_operations = sum(len(job) for job in duration_matrix)
+    avg_ops_per_job = total_operations / max(1, num_jobs)
+    return round(total_duration / max(1, avg_ops_per_job))
+
+
+def get_independent_release_date_strategy(
+    max_release_time: int,
+) -> ReleaseDateStrategy:
+    """Factory for an independent (pure random) release date strategy.
+
+    The release date is drawn uniformly at random in the interval
+    ``[0, max_release_time]``.
+
+    Args:
+        max_release_time:
+            Inclusive upper bound for the random value.
+
+    Returns:
+        A callable implementing the independent release date strategy.
+
+    .. versionadded:: 1.7.0
+    """
+    if max_release_time < 0:
+        raise ValidationError("'max_release_time' must be >= 0.")
+
+    def _strategy(rng: random.Random, unused_cumulative_prev: int) -> int:
+        return int(rng.randint(0, max_release_time))
+
+    return _strategy
+
+
+def get_cumulative_release_date_strategy(
+    maximum_slack: int = 0,
+) -> ReleaseDateStrategy:
+    """Factory for a cumulative strategy allowing forward slack.
+
+    The release date is the cumulative previous processing time plus a
+    random slack in ``[0, maximum_slack]``.
+
+    Args:
+        maximum_slack:
+            Non-negative integer defining the maximum forward slack to add.
+
+    Returns:
+        A callable implementing the cumulative release date strategy.
+    """
+    if maximum_slack < 0:
+        raise ValidationError("'maximum_slack' must be >= 0.")
+
+    def _strategy(rng: random.Random, cumulative_prev: int) -> int:
+        return cumulative_prev + rng.randint(0, maximum_slack)
+
+    return _strategy
+
+
+def get_mixed_release_date_strategy(
+    alpha: float,
+    beta: float,
+    horizon_proxy: int,
+) -> ReleaseDateStrategy:
+    """Factory for the mixed heuristic strategy.
+
+    release_date = alpha * cumulative_previous + U(0, beta * horizon_proxy)
+
+    Args:
+        alpha:
+            Weight for the proportional cumulative component.
+        beta:
+            Weight for the random component upper bound.
+        horizon_proxy:
+            Non-negative proxy for the time horizon (e.g. derived
+            from durations to scale the random component consistently).
+    """
+    if horizon_proxy < 0:
+        raise ValidationError("'horizon_proxy' must be >= 0.")
+
+    random_component_upper = round(beta * horizon_proxy)
+
+    def _strategy(rng: random.Random, cumulative_prev: int) -> int:
+        random_component = rng.randint(0, random_component_upper)
+        return round(alpha * cumulative_prev) + random_component
+
+    return _strategy

job_shop_lib/generation/_size_selectors.py

@@ -0,0 +1,58 @@
+import random
+
+
+def range_size_selector(
+    rng: random.Random,
+    num_jobs_range: tuple[int, int] = (10, 20),
+    num_machines_range: tuple[int, int] = (5, 10),
+    allow_less_jobs_than_machines: bool = True,
+) -> tuple[int, int]:
+    """Selects the number of jobs and machines based on the provided ranges
+    and constraints.
+
+    Args:
+        rng:
+            A ``random.Random`` instance.
+        num_jobs_range:
+            A tuple specifying the inclusive range for the number of jobs.
+        num_machines_range:
+            A tuple specifying the inclusive range for the number of machines.
+        allow_less_jobs_than_machines:
+            If ``False``, ensures that the number of jobs is not less than the
+            number of machines.
+
+    Returns:
+        A tuple containing the selected number of jobs and machines.
+    """
+    num_jobs = rng.randint(num_jobs_range[0], num_jobs_range[1])
+
+    min_num_machines, max_num_machines = num_machines_range
+    if not allow_less_jobs_than_machines:
+        # Cap the maximum machines to the sampled number of jobs.
+        max_num_machines = min(max_num_machines, num_jobs)
+        # If min > capped max, collapse interval so we return a valid value
+        # (e.g. jobs=3, range=(5,10)).
+        if min_num_machines > max_num_machines:
+            min_num_machines = max_num_machines
+    num_machines = rng.randint(min_num_machines, max_num_machines)
+
+    return num_jobs, num_machines
+
+
+def choice_size_selector(
+    rng: random.Random,
+    options: list[tuple[int, int]],
+) -> tuple[int, int]:
+    """Selects the number of jobs and machines from a list of options.
+
+    Args:
+        rng:
+            A ``random.Random`` instance.
+        options:
+            A list of tuples, where each tuple contains a pair of integers
+            representing the number of jobs and machines.
+
+    Returns:
+        A tuple containing the selected number of jobs and machines.
+    """
+    return rng.choice(options)

job_shop_lib/metaheuristics/__init__.py

@@ -31,12 +31,16 @@ contribute!
     swap_random_operations
     ObjectiveFunction
     get_makespan_with_penalties_objective
+    compute_penalty_for_deadlines
+    compute_penalty_for_due_dates
 
 """
 
 from job_shop_lib.metaheuristics._objective_functions import (
     ObjectiveFunction,
     get_makespan_with_penalties_objective,
+    compute_penalty_for_deadlines,
+    compute_penalty_for_due_dates,
 )
 from job_shop_lib.metaheuristics._neighbor_generators import (
     NeighborGenerator,
@@ -58,4 +62,6 @@ __all__ = [
     "swap_random_operations",
     "ObjectiveFunction",
     "get_makespan_with_penalties_objective",
+    "compute_penalty_for_deadlines",
+    "compute_penalty_for_due_dates",
 ]

job_shop_lib/metaheuristics/_objective_functions.py

@@ -45,29 +45,70 @@ def get_makespan_with_penalties_objective(
 
     def objective(schedule: Schedule) -> float:
         makespan = schedule.makespan()
-        instance = schedule.instance
-
-        # Fast path: no constraint attributes present in the instance
-        if not instance.has_deadlines and not instance.has_due_dates:
-            return makespan
-
-        penalty = 0.0
-        for machine_schedule in schedule.schedule:
-            for scheduled_op in machine_schedule:
-                op = scheduled_op.operation
-                # Deadline (hard) penalty
-                if (
-                    op.deadline is not None
-                    and scheduled_op.end_time > op.deadline
-                ):
-                    penalty += deadline_penalty_factor
-                # Due date (soft) penalty
-                if (
-                    op.due_date is not None
-                    and scheduled_op.end_time > op.due_date
-                ):
-                    penalty += due_date_penalty_factor
+        penalty_for_deadlines = compute_penalty_for_deadlines(
+            schedule, deadline_penalty_factor
+        )
+        penalty_for_due_dates = compute_penalty_for_due_dates(
+            schedule, due_date_penalty_factor
+        )
+        penalty = penalty_for_deadlines + penalty_for_due_dates
 
         return makespan + penalty
 
     return objective
+
+
+def compute_penalty_for_deadlines(
+    schedule: Schedule, penalty_per_violation: float
+) -> float:
+    """Compute the total penalty for deadline violations in a schedule.
+
+    Args:
+        schedule:
+            The schedule to evaluate.
+        penalty_per_violation:
+            The penalty to apply for each operation that
+            finishes after its deadline.
+
+    Returns:
+        The total penalty for deadline violations.
+    """
+    if not schedule.instance.has_deadlines or penalty_per_violation == 0:
+        return 0.0
+
+    penalty = 0.0
+    for machine_schedule in schedule.schedule:
+        for scheduled_op in machine_schedule:
+            op = scheduled_op.operation
+            if op.deadline is not None and scheduled_op.end_time > op.deadline:
+                penalty += penalty_per_violation
+
+    return penalty
+
+
+def compute_penalty_for_due_dates(
+    schedule: Schedule, penalty_per_violation: float
+) -> float:
+    """Compute the total penalty for due date violations in a schedule.
+
+    Args:
+        schedule:
+            The schedule to evaluate.
+        penalty_per_violation:
+            The penalty to apply for each operation that
+            finishes after its due date.
+
+    Returns:
+        The total penalty for due date violations.
+    """
+    if not schedule.instance.has_due_dates or penalty_per_violation == 0:
+        return 0.0
+
+    penalty = 0.0
+    for machine_schedule in schedule.schedule:
+        for scheduled_op in machine_schedule:
+            op = scheduled_op.operation
+            if op.due_date is not None and scheduled_op.end_time > op.due_date:
+                penalty += penalty_per_violation
+
+    return penalty

job_shop_lib/reinforcement_learning/__init__.py

@@ -14,11 +14,14 @@
     RewardObserver
     MakespanReward
     IdleTimeReward
+    RewardWithPenalties
     RenderConfig
     add_padding
     create_edge_type_dict
     map_values
     get_optimal_actions
+    get_deadline_violation_penalty
+    get_due_date_violation_penalty
 
 """
 
@@ -32,6 +35,7 @@ from job_shop_lib.reinforcement_learning._reward_observers import (
     RewardObserver,
     MakespanReward,
     IdleTimeReward,
+    RewardWithPenalties,
 )
 
 from job_shop_lib.reinforcement_learning._utils import (
@@ -39,6 +43,8 @@ from job_shop_lib.reinforcement_learning._utils import (
     create_edge_type_dict,
     map_values,
     get_optimal_actions,
+    get_deadline_violation_penalty,
+    get_due_date_violation_penalty,
 )
 
 from job_shop_lib.reinforcement_learning._single_job_shop_graph_env import (
@@ -63,9 +69,12 @@ __all__ = [
     "RewardObserver",
     "MakespanReward",
     "IdleTimeReward",
+    "RewardWithPenalties",
     "RenderConfig",
     "add_padding",
     "create_edge_type_dict",
     "map_values",
     "get_optimal_actions",
+    "get_deadline_violation_penalty",
+    "get_due_date_violation_penalty",
 ]

job_shop_lib/reinforcement_learning/_reward_observers.py

@@ -1,6 +1,9 @@
 """Rewards functions are defined as `DispatcherObervers` and are used to
 calculate the reward for a given state."""
 
+from collections.abc import Callable
+
+from job_shop_lib.exceptions import ValidationError
 from job_shop_lib.dispatching import DispatcherObserver, Dispatcher
 from job_shop_lib import ScheduledOperation
 
@@ -83,3 +86,76 @@ class IdleTimeReward(RewardObserver):
 
         reward = -idle_time
         self.rewards.append(reward)
+
+
+class RewardWithPenalties(RewardObserver):
+    """Reward function that adds penalties to another reward function.
+
+    The reward is calculated as the sum of the reward from another reward
+    function and a penalty for each constraint violation (due dates and
+    deadlines).
+
+    Attributes:
+        base_reward_observer:
+            The base reward observer to use for calculating the reward.
+        penalty_function:
+            A function that takes a scheduled operation and the dispatcher as
+            input and returns the penalty for that operation.
+
+    Args:
+        dispatcher:
+            The dispatcher to observe.
+        base_reward_observer:
+            The base reward observer to use for calculating the reward. It
+            must use the same dispatcher as this reward observer. If it is
+            subscribed to the dispatcher, it will be unsubscribed.
+        penalty_function:
+            A function that takes a scheduled operation and the
+            dispatcher as input and returns the penalty for that operation.
+        subscribe:
+            Whether to subscribe to the dispatcher upon initialization.
+
+    Raises:
+        ValidationError:
+            If the base reward observer does not use the same dispatcher as
+            this reward observer.
+
+    .. versionadded:: 1.7.0
+
+    .. seealso::
+        The following functions (along with ``functools.partial``) can be
+        used to create penalty functions:
+
+        - :func:`~job_shop_lib.reinforcement_learning.get_deadline_violation_penalty`
+        - :func:`~job_shop_lib.reinforcement_learning.get_due_date_violation_penalty`
+
+    """  # noqa: E501
+
+    def __init__(
+        self,
+        dispatcher: Dispatcher,
+        *,
+        base_reward_observer: RewardObserver,
+        penalty_function: Callable[[ScheduledOperation, Dispatcher], float],
+        subscribe: bool = True,
+    ) -> None:
+        super().__init__(dispatcher, subscribe=subscribe)
+        self.base_reward_observer = base_reward_observer
+        self.penalty_function = penalty_function
+        if base_reward_observer.dispatcher is not dispatcher:
+            raise ValidationError(
+                "The base reward observer must use the same "
+                "dispatcher as this reward observer."
+            )
+        if base_reward_observer in dispatcher.subscribers:
+            dispatcher.unsubscribe(base_reward_observer)
+
+    def reset(self) -> None:
+        super().reset()
+        self.base_reward_observer.reset()
+
+    def update(self, scheduled_operation: ScheduledOperation):
+        self.base_reward_observer.update(scheduled_operation)
+        base_reward = self.base_reward_observer.last_reward
+        penalty = self.penalty_function(scheduled_operation, self.dispatcher)
+        self.rewards.append(base_reward - penalty)

job_shop_lib/reinforcement_learning/_utils.py

@@ -5,8 +5,9 @@ from typing import TypeVar, Any
 import numpy as np
 from numpy.typing import NDArray
 
+from job_shop_lib import ScheduledOperation
 from job_shop_lib.exceptions import ValidationError
-from job_shop_lib.dispatching import OptimalOperationsObserver
+from job_shop_lib.dispatching import OptimalOperationsObserver, Dispatcher
 
 T = TypeVar("T", bound=np.number)
 
@@ -193,7 +194,65 @@ def get_optimal_actions(
     return optimal_actions
 
 
-if __name__ == "__main__":
-    import doctest
+def get_deadline_violation_penalty(
+    scheduled_operation: ScheduledOperation,
+    unused_dispatcher: Dispatcher,
+    deadline_penalty_factor: float = 10_000,
+) -> float:
+    """Compute the penalty for a scheduled operation that violates its
+    deadline.
 
-    doctest.testmod()
+    Args:
+        scheduled_operation:
+            The scheduled operation to evaluate.
+        unused_dispatcher:
+            This argument is unused but included for compatibility with the
+            penalty function signature.
+        deadline_penalty_factor:
+            Cost added for each operation that
+            finishes after its deadline. Defaults to 10_000.
+    Returns:
+        The penalty for the scheduled operation if it violates its deadline,
+        otherwise 0.
+
+    .. versionadded:: 1.7.0
+    """
+    if (
+        scheduled_operation.operation.deadline is not None
+        and scheduled_operation.end_time
+        > scheduled_operation.operation.deadline
+    ):
+        return deadline_penalty_factor
+    return 0.0
+
+
+def get_due_date_violation_penalty(
+    scheduled_operation: ScheduledOperation,
+    unused_dispatcher: Dispatcher,
+    due_date_penalty_factor: float = 100,
+) -> float:
+    """Compute the penalty for a scheduled operation that violates its
+    due date.
+
+    Args:
+        scheduled_operation:
+            The scheduled operation to evaluate.
+        unused_dispatcher:
+            This argument is unused but included for compatibility with the
+            penalty function signature.
+        due_date_penalty_factor:
+            Cost added for each operation that
+            finishes after its due date. Defaults to 100.
+    Returns:
+        The penalty for the scheduled operation if it violates its due date,
+        otherwise 0.
+
+    .. versionadded:: 1.7.0
+    """
+    if (
+        scheduled_operation.operation.due_date is not None
+        and scheduled_operation.end_time
+        > scheduled_operation.operation.due_date
+    ):
+        return due_date_penalty_factor
+    return 0.0

{job_shop_lib-1.6.1.dist-info → job_shop_lib-1.7.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: job-shop-lib
-Version: 1.6.1
+Version: 1.7.0
 Summary: An easy-to-use and modular Python library for the Job Shop Scheduling Problem (JSSP)
 License: MIT
 Author: Pabloo22
@@ -45,13 +45,13 @@ It follows a modular design, allowing users to easily extend the library with ne
 We support multiple solvers, including:
 - **Constraint Programming**: Based on OR-Tools' CP-SAT solver. It supports **release dates, deadlines, and due dates.** See the ["Solving the Problem" tutorial](https://github.com/Pabloo22/job_shop_lib/blob/main/docs/source/tutorial/02-Solving-the-Problem.ipynb) for an example.
 - **Dispatching Rules**: A set of predefined rules and the ability to create custom ones. They support arbitrary **setup times, machine breakdowns, release dates, deadlines, and due dates**. See the [following example](https://github.com/Pabloo22/job_shop_lib/blob/main/docs/source/examples/03-Dispatching-Rules.ipynb). You can also create videos or GIFs of the scheduling process. For creating GIFs or videos, see the [Save Gif example](https://github.com/Pabloo22/job_shop_lib/blob/main/docs/source/examples/04-Save-Gif.ipynb).
-- **Metaheuristics**: Currently, we have a **simulated annealing** implementation that supports **release dates, deadlines, and due dates**. We also support arbitrary neighborhood search strategies, including swapping operations in the critical path as described in the paper "Job Shop Scheduling by Simulated Annealing" by van Laarhoven et al. (1992); and energy functions. See our [simulated annealing tutorial](https://github.com/Pabloo22/job_shop_lib/blob/main/docs/source/tutorial/03-Simulated-Annealing.ipynb).
+- **Metaheuristics**: Currently, we have a **simulated annealing** implementation that supports **release dates, deadlines, and due dates**. We also support arbitrary neighborhood search strategies, including swapping operations in the critical path as described in the paper "Job Shop Scheduling by Simulated Annealing" by van Laarhoven et al. (1992); and energy functions. See our [simulated annealing tutorial](https://github.com/Pabloo22/job_shop_lib/blob/main/docs/source/tutorial/04-Simulated-Annealing.ipynb).
 - **Reinforcement Learning**: Two Gymnasium environments for solving the problem with **graph neural networks** (GNNs) or any other method. The environments support **setup times, release dates, deadlines, and due dates.** We're currently building a tutorial on how to use them.
 
 We also provide useful utilities, data structures, and visualization functions:
 - **Intuitive Data Structures**: Easily create, manage, and manipulate job shop instances and solutions with user-friendly data structures. See [Getting Started](https://github.com/Pabloo22/job_shop_lib/blob/main/docs/source/tutorial/00-Getting-Started.ipynb) and [How Solutions are Represented](https://github.com/Pabloo22/job_shop_lib/blob/main/docs/source/tutorial/01-How-Solutions-are-Represented.ipynb).
 - **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. See [`generation`](https://job-shop-lib.readthedocs.io/en/stable/api/job_shop_lib.generation.html#module-job_shop_lib.generation) module.
+- **Random Instance Generation**: Create random instances with customizable sizes and properties. See [`this tutorial`](https://github.com/Pabloo22/job_shop_lib/blob/main/docs/source/tutorial/03-Generating-New-Instances.ipynb).
 - **Gantt Charts**: Visualize final schedules and how they are created iteratively by dispatching rule solvers or sequences of scheduling decisions with GIFs or videos.
 - **Graph Representations**: Represent and visualize instances as disjunctive graphs or agent-task graphs (introduced in the ScheduleNet paper). Build your own custom graphs with the `JobShopGraph` class. See the [Disjunctive Graphs](https://github.com/Pabloo22/job_shop_lib/blob/main/docs/source/tutorial/04-Disjunctive-Graphs.ipynb) and [Resource Task Graphs](https://job-shop-lib.readthedocs.io/en/stable/examples/07-Resource-Task-Graph.html) examples.
 

{job_shop_lib-1.6.1.dist-info → job_shop_lib-1.7.0.dist-info}/RECORD

@@ -1,11 +1,11 @@
-job_shop_lib/__init__.py,sha256=_kA4WyA9KQUW4ZXB4anAXrhQfvhrLj38YLLHovGvFfA,639
+job_shop_lib/__init__.py,sha256=2tXYQ5nb_6v3J7mpsXC1vRMI2khj2BTRijff-8j6ZLY,639
 job_shop_lib/_base_solver.py,sha256=8CCSiA2-DegCKRXhMw7yYyI8iPauTSuLku2LQ8dU-9U,1382
-job_shop_lib/_job_shop_instance.py,sha256=_92orxdi70645J7cQlRE1I0PebvpHRCP6958q9j2h18,24261
+job_shop_lib/_job_shop_instance.py,sha256=tQDJwKCgimzAcEK6vdAAePKiF_5AvOmzHZcOptfVkd0,25403
 job_shop_lib/_operation.py,sha256=JI5WjvRXNBeSpPOv3ZwSrUJ4jsVDJYKfMaDHYOaFYts,5945
 job_shop_lib/_schedule.py,sha256=jvidw6iIh05QGe2OeA6JkiQuCzLoOtgqny8zj95_sGA,18173
 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/__init__.py,sha256=M4hGy3PbNoNtcYUAJkGTYfPnk3hFVkhg5BYr6g3iB6Q,3369
+job_shop_lib/benchmarking/_load_benchmark.py,sha256=5NvDXKvwtff9Vw6y5R2f2I2r2YNekMbQsSt0GXzZeao,3684
 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=trTQtqSL2F2PXxd9RPnFhxaY8blNcfFUhTdab5QP9VU,12585
@@ -21,8 +21,8 @@ job_shop_lib/dispatching/_unscheduled_operations_observer.py,sha256=0he-j4OlvqtX
 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/_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/_duration_observer.py,sha256=3Z8CA9k4OKKjVcclCnyUrtr7USM7M4rSvp2hhwUir3A,4224
+job_shop_lib/dispatching/feature_observers/_earliest_start_time_observer.py,sha256=Jm6g3LUwVCiXVghSsJ1XyaxfAu5sYT1t8OunfVjHDqc,11451
 job_shop_lib/dispatching/feature_observers/_factory.py,sha256=NyXYK5A1hXsYEeEqngwVRNAFkevY95DglheeqyfFv8s,3217
 job_shop_lib/dispatching/feature_observers/_feature_observer.py,sha256=qbgtMUicQ5FWS-Ql4Izjsj4QrevfOGlWzoJ0JlVSLH0,8668
 job_shop_lib/dispatching/feature_observers/_is_completed_observer.py,sha256=EYJOyWL8ApUElLucoHnFlt0g2Ior_1yO7Q8V3FU_Qog,3576
@@ -37,10 +37,14 @@ job_shop_lib/dispatching/rules/_dispatching_rules_functions.py,sha256=c-T6jUXZ2w
 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/__init__.py,sha256=6H94ZsuvaRWIFzvDFPvCoaqNTLp_R2RL0DgLl47IC2s,2197
+job_shop_lib/generation/_duration_matrix.py,sha256=l6T06SGUYQC0BFgQhw2j7RLi7yrK_CLunGuYmAyWglQ,2475
 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=b3SVU5DY3-VHXX2yrOwM7ABDSexiSFSRbo1d5QjRfoI,3972
+job_shop_lib/generation/_instance_generator.py,sha256=wnXk3dS7TQu5fNPsbkqbjvcuUdaZ2XE0w9ITsSVLiyY,4628
+job_shop_lib/generation/_machine_matrix.py,sha256=l56h0b1I39_zTm5h0Hnc217V5vmnEB-k8_xoxGL4taw,3928
+job_shop_lib/generation/_modular_instance_generator.py,sha256=pDwhbCKc85kTUCuQZEKirF-ILnv67Ln618jhTn_ltis,3900
+job_shop_lib/generation/_release_date_matrix.py,sha256=rv-lcqg-z3uYgsoEKPf1r7iGZsKXf9tnSkvMxEmx-Oc,4981
+job_shop_lib/generation/_size_selectors.py,sha256=y9jUOjR3hCk0dUU3H_Xce4Pok7X-YVybTuP_GK66CuQ,1969
 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
@@ -52,19 +56,19 @@ job_shop_lib/graphs/graph_updaters/_disjunctive_graph_updater.py,sha256=-t0T8W-J
 job_shop_lib/graphs/graph_updaters/_graph_updater.py,sha256=j1f7iWsa62GVszK2BPaMxnKBCEGWa9owm8g4VWUje8w,1967
 job_shop_lib/graphs/graph_updaters/_residual_graph_updater.py,sha256=9NG3pu7Z5h-ZTfX8rRiZbI_NfNQi80h-XUHainshjZY,6064
 job_shop_lib/graphs/graph_updaters/_utils.py,sha256=sdw2Vo75P9c6Fy-YBlfgpXb9gPwHUluTB1E-9WINm_g,730
-job_shop_lib/metaheuristics/__init__.py,sha256=z7bHN5vP-ctOSL0eUYK-aRyhRkU2lrDyA4kBs15EME0,1884
+job_shop_lib/metaheuristics/__init__.py,sha256=CfuajbzO1J21_FsA1J_6UpODvPSwzi_VNAh7xEEoe_Q,2096
 job_shop_lib/metaheuristics/_job_shop_annealer.py,sha256=Ty4SLPZh1NrL-XRqU76EeN8fwUdKfqbphqfYEDje1lQ,9195
 job_shop_lib/metaheuristics/_neighbor_generators.py,sha256=3RePlnYvJdpdhObmf0m_3NhyUM7avfNr4vOZT0PWTRQ,6563
-job_shop_lib/metaheuristics/_objective_functions.py,sha256=GG5M3LoLnNzo1zxzfpNMvo4bdYlqWuhVA8mIkXFsxxM,2607
+job_shop_lib/metaheuristics/_objective_functions.py,sha256=XovebJbvUyuwgcnS6C8P-hGlMXZ7bFxKOM2He5NUH0Q,3727
 job_shop_lib/metaheuristics/_simulated_annealing_solver.py,sha256=EMCrFl2zzJubrvCMi5upm8lnUgtBizhZbi4EvbnIsM4,6200
 job_shop_lib/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-job_shop_lib/reinforcement_learning/__init__.py,sha256=sAVgxylKfBnn2rrz0BFcab1kjvQQ1h-hgldfbkPF--E,1537
+job_shop_lib/reinforcement_learning/__init__.py,sha256=aPB3XqOzRxtpjL5S3kjNXZa7L8Z2OFnO48J5wTc9DbQ,1831
 job_shop_lib/reinforcement_learning/_multi_job_shop_graph_env.py,sha256=6nXw67Tfmim3LqlSuQ9Cfg3mMY-VmbMHuXfyOL90jng,15740
 job_shop_lib/reinforcement_learning/_resource_task_graph_observation.py,sha256=ZqN6kzuXbO0BdA1UKrTEHeiHAKzRNIeuH-dBt90ttEc,12914
-job_shop_lib/reinforcement_learning/_reward_observers.py,sha256=4Kdyn9Jlp_1sBtVr6raF-ZFtcnKxwyCLykfX53TmuhU,2959
+job_shop_lib/reinforcement_learning/_reward_observers.py,sha256=CBQ-QrTs4ymYEqqIsAXnsiEXX5BgakOrT1FweM87l_4,5858
 job_shop_lib/reinforcement_learning/_single_job_shop_graph_env.py,sha256=MnQYCVpwX4WHiGhYguHziDUrPIrKmXsjOUDoTmuoCBc,16403
 job_shop_lib/reinforcement_learning/_types_and_constants.py,sha256=6FpuQkZLV2H8_dXmax49OTgAw7dWQcUEWVWWdMLR7bs,1752
-job_shop_lib/reinforcement_learning/_utils.py,sha256=aHgNdW7YvUH8QM3l7NGIfrgzfpzGoklyYm1jM2Isi6Q,6043
+job_shop_lib/reinforcement_learning/_utils.py,sha256=sxKFulDrt1Aei3etLEgsdFVFRmXKNIhFLoOKOWqIz00,8022
 job_shop_lib/visualization/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 job_shop_lib/visualization/gantt/__init__.py,sha256=xMvuNph6bfwulHYqqklCj_6SUQgRzvC92Yul75F3Zlg,1250
 job_shop_lib/visualization/gantt/_gantt_chart_creator.py,sha256=FgE4SmKLYKnS7dfTFgnBklWhwGyIo0DKWVkmxusDmp8,8606
@@ -73,7 +77,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.6.1.dist-info/LICENSE,sha256=9mggivMGd5taAu3xbmBway-VQZMBzurBGHofFopvUsQ,1069
-job_shop_lib-1.6.1.dist-info/METADATA,sha256=4cuNTeLFoaVOMBqGvymRzwXKgTHQSt3ZgQ-iKr0Xs1s,19159
-job_shop_lib-1.6.1.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-job_shop_lib-1.6.1.dist-info/RECORD,,
+job_shop_lib-1.7.0.dist-info/LICENSE,sha256=9mggivMGd5taAu3xbmBway-VQZMBzurBGHofFopvUsQ,1069
+job_shop_lib-1.7.0.dist-info/METADATA,sha256=goMjnzDFnjTYw4BEwApgq5gSs9SZtFr98WR8qRakRs0,19151
+job_shop_lib-1.7.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+job_shop_lib-1.7.0.dist-info/RECORD,,