job-shop-lib 1.6.0__tar.gz → 1.7.0__tar.gz

{job_shop_lib-1.6.0 → job_shop_lib-1.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: job-shop-lib
-Version: 1.6.0
+Version: 1.7.0
 Summary: An easy-to-use and modular Python library for the Job Shop Scheduling Problem (JSSP)
 License: MIT
 Author: Pabloo22
@@ -17,8 +17,7 @@ Requires-Dist: imageio[ffmpeg] (>=2.34.1,<3.0.0)
 Requires-Dist: matplotlib (>=3,<4)
 Requires-Dist: networkx (>=3,<4)
 Requires-Dist: numpy (>=1.26.4,<3.0.0)
-Requires-Dist: ortools (>=9.9,<10.0) ; sys_platform != "darwin"
-Requires-Dist: ortools (>=9.9,<9.13) ; sys_platform == "darwin"
+Requires-Dist: ortools (>=9.9,<9.13)
 Requires-Dist: pyarrow (>=15,<21)
 Requires-Dist: pygraphviz (>=1.12,<2.0) ; extra == "pygraphviz"
 Requires-Dist: simanneal (>=0.5.0,<0.6.0)
@@ -46,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.0 → job_shop_lib-1.7.0}/README.md

@@ -20,13 +20,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.0 → job_shop_lib-1.7.0}/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.0"
+__version__ = "1.7.0"
 
 __all__ = [
     "Operation",

{job_shop_lib-1.6.0 → job_shop_lib-1.7.0}/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-1.6.0 → job_shop_lib-1.7.0}/job_shop_lib/_schedule.py

@@ -405,10 +405,15 @@ class Schedule:
         critical_path = deque([last_scheduled_op])
         current_scheduled_op = last_scheduled_op
 
+        machine_op_index = {}
+        for machine_id, schedule_list in enumerate(self.schedule):
+            machine_op_index[machine_id] = {op: idx for idx, op in
+                                            enumerate(schedule_list)}
+
         # 2. Trace backwards from the last operation
         while True:
-            job_pred = None
-            machine_pred = None
+            job_pred: ScheduledOperation | None = None
+            machine_pred: ScheduledOperation | None = None
 
             # Find job predecessor (the previous operation in the same job)
             op_idx_in_job = current_scheduled_op.operation.position_in_job
@@ -423,9 +428,13 @@ class Schedule:
             # Find machine predecessor (the previous operation on the same
             # machine)
             machine_schedule = self.schedule[current_scheduled_op.machine_id]
-            op_idx_on_machine = machine_schedule.index(current_scheduled_op)
+            op_idx_on_machine = (
+                machine_op_index
+                [current_scheduled_op.machine_id][current_scheduled_op])
             if op_idx_on_machine > 0:
-                machine_pred = machine_schedule[op_idx_on_machine - 1]
+                machine_pred = machine_schedule[
+                    op_idx_on_machine - 1
+                ]
 
             # 3. Determine the critical predecessor
             # The critical predecessor is the one that finished latest, as it

{job_shop_lib-1.6.0 → job_shop_lib-1.7.0}/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-1.6.0 → job_shop_lib-1.7.0}/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-1.6.0 → job_shop_lib-1.7.0}/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-1.6.0 → job_shop_lib-1.7.0}/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-1.7.0/job_shop_lib/generation/__init__.py

@@ -0,0 +1,71 @@
+"""Package for generating job shop instances.
+
+.. autosummary::
+    :nosignatures:
+
+    InstanceGenerator
+    GeneralInstanceGenerator
+    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._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 (
+    GeneralInstanceGenerator,
+)
+
+__all__ = [
+    "InstanceGenerator",
+    "GeneralInstanceGenerator",
+    "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-1.7.0/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-1.6.0 → job_shop_lib-1.7.0}/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-1.6.0/job_shop_lib/generation/_utils.py → job_shop_lib-1.7.0/job_shop_lib/generation/_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)