job-shop-lib 1.0.0a5__py3-none-any.whl → 1.0.0b1__py3-none-any.whl

job_shop_lib/dispatching/_ready_operation_filters.py

@@ -4,6 +4,7 @@ This functions are used by the `Dispatcher` class to reduce the
 amount of available operations to choose from.
 """
 
+from typing import List, Set
 from collections.abc import Callable
 
 from job_shop_lib import Operation
@@ -11,13 +12,13 @@ from job_shop_lib.dispatching import Dispatcher
 
 
 ReadyOperationsFilter = Callable[
-    [Dispatcher, list[Operation]], list[Operation]
+    [Dispatcher, List[Operation]], List[Operation]
 ]
 
 
 def filter_non_idle_machines(
-    dispatcher: Dispatcher, operations: list[Operation]
-) -> list[Operation]:
+    dispatcher: Dispatcher, operations: List[Operation]
+) -> List[Operation]:
     """Filters out all the operations associated with non-idle machines.
 
     A machine is considered idle if there are no ongoing operations
@@ -40,7 +41,7 @@ def filter_non_idle_machines(
 
     # Filter operations to keep those that are associated with at least one
     # idle machine
-    filtered_operations: list[Operation] = []
+    filtered_operations: List[Operation] = []
     for operation in operations:
         if all(
             machine_id in non_idle_machines
@@ -54,7 +55,7 @@ def filter_non_idle_machines(
 
 def _get_non_idle_machines(
     dispatcher: Dispatcher, current_time: int
-) -> set[int]:
+) -> Set[int]:
     """Returns the set of machine ids that are currently busy (i.e., have at
     least one uncompleted operation)."""
 
@@ -70,8 +71,8 @@ def _get_non_idle_machines(
 
 
 def filter_non_immediate_operations(
-    dispatcher: Dispatcher, operations: list[Operation]
-) -> list[Operation]:
+    dispatcher: Dispatcher, operations: List[Operation]
+) -> List[Operation]:
     """Filters out all the operations that can't start immediately.
 
     An operation can start immediately if its earliest start time is the
@@ -86,7 +87,7 @@ def filter_non_immediate_operations(
     """
 
     min_start_time = dispatcher.min_start_time(operations)
-    immediate_operations: list[Operation] = []
+    immediate_operations: List[Operation] = []
     for operation in operations:
         start_time = dispatcher.earliest_start_time(operation)
         if start_time == min_start_time:
@@ -96,8 +97,8 @@ def filter_non_immediate_operations(
 
 
 def filter_dominated_operations(
-    dispatcher: Dispatcher, operations: list[Operation]
-) -> list[Operation]:
+    dispatcher: Dispatcher, operations: List[Operation]
+) -> List[Operation]:
     """Filters out all the operations that are dominated.
     An operation is dominated if there is another operation that ends before
     it starts on the same machine.
@@ -105,7 +106,7 @@ def filter_dominated_operations(
 
     min_machine_end_times = _get_min_machine_end_times(dispatcher, operations)
 
-    non_dominated_operations: list[Operation] = []
+    non_dominated_operations: List[Operation] = []
     for operation in operations:
         # One benchmark instance has an operation with duration 0
         if operation.duration == 0:
@@ -121,13 +122,13 @@ def filter_dominated_operations(
 
 
 def filter_non_immediate_machines(
-    dispatcher: Dispatcher, operations: list[Operation]
-) -> list[Operation]:
+    dispatcher: Dispatcher, operations: List[Operation]
+) -> List[Operation]:
     """Filters out all the operations associated with machines which earliest
     operation is not the current time."""
 
     is_immediate_machine = _get_immediate_machines(dispatcher, operations)
-    non_dominated_operations: list[Operation] = []
+    non_dominated_operations: List[Operation] = []
     for operation in operations:
         if any(
             is_immediate_machine[machine_id]
@@ -139,8 +140,8 @@ def filter_non_immediate_machines(
 
 
 def _get_min_machine_end_times(
-    dispatcher: Dispatcher, available_operations: list[Operation]
-) -> list[int | float]:
+    dispatcher: Dispatcher, available_operations: List[Operation]
+) -> List[float]:
     end_times_per_machine = [float("inf")] * dispatcher.instance.num_machines
     for op in available_operations:
         for machine_id in op.machines:
@@ -152,8 +153,8 @@ def _get_min_machine_end_times(
 
 
 def _get_immediate_machines(
-    self: Dispatcher, available_operations: list[Operation]
-) -> list[bool]:
+    self: Dispatcher, available_operations: List[Operation]
+) -> List[bool]:
     """Returns the machine ids of the machines that have at least one
     operation with the lowest start time (i.e. the start time)."""
     working_machines = [False] * self.instance.num_machines

job_shop_lib/dispatching/_unscheduled_operations_observer.py

@@ -3,7 +3,7 @@
 import collections
 from collections.abc import Iterable
 import itertools
-from typing import Deque
+from typing import Deque, List
 
 from job_shop_lib import Operation, ScheduledOperation
 from job_shop_lib.dispatching import DispatcherObserver, Dispatcher
@@ -19,7 +19,7 @@ class UnscheduledOperationsObserver(DispatcherObserver):
 
     def __init__(self, dispatcher: Dispatcher, *, subscribe: bool = True):
         super().__init__(dispatcher, subscribe=subscribe)
-        self.unscheduled_operations_per_job: list[Deque[Operation]] = []
+        self.unscheduled_operations_per_job: List[Deque[Operation]] = []
         self.reset()
         # In case the dispatcher has already scheduled some operations,
         # we need to remove them.
@@ -51,7 +51,8 @@ class UnscheduledOperationsObserver(DispatcherObserver):
         unscheduled operations.
 
         Args:
-            scheduled_operation: The operation that has been scheduled.
+            scheduled_operation:
+                The operation that has been scheduled.
         """
         job_id = scheduled_operation.operation.job_id
         job_deque = self.unscheduled_operations_per_job[job_id]

job_shop_lib/dispatching/feature_observers/_composite_feature_observer.py

@@ -2,12 +2,11 @@
 
 from collections import defaultdict
 from collections.abc import Sequence
-
+from typing import List, Dict, Union, Optional
 # The Self type can be imported directly from Python’s typing module in
 # version 3.11 and beyond. We use the typing_extensions module to support
-# python 3.10.
+# python >=3.8
 from typing_extensions import Self
-
 import numpy as np
 from numpy.typing import NDArray
 import pandas as pd
@@ -77,8 +76,8 @@ class CompositeFeatureObserver(FeatureObserver):
         dispatcher: Dispatcher,
         *,
         subscribe: bool = True,
-        feature_types: list[FeatureType] | FeatureType | None = None,
-        feature_observers: list[FeatureObserver] | None = None,
+        feature_types: Optional[Union[List[FeatureType], FeatureType]] = None,
+        feature_observers: Optional[List[FeatureObserver]] = None,
     ):
         if feature_observers is None:
             feature_observers = [
@@ -97,7 +96,7 @@ class CompositeFeatureObserver(FeatureObserver):
                     f"Composite feature types: {feature_types}"
                 )
         self.feature_observers = feature_observers
-        self.column_names: dict[FeatureType, list[str]] = defaultdict(list)
+        self.column_names: Dict[FeatureType, List[str]] = defaultdict(list)
         super().__init__(dispatcher, subscribe=subscribe)
         self._set_column_names()
 
@@ -129,7 +128,7 @@ class CompositeFeatureObserver(FeatureObserver):
         return composite_observer
 
     @property
-    def features_as_dataframe(self) -> dict[FeatureType, pd.DataFrame]:
+    def features_as_dataframe(self) -> Dict[FeatureType, pd.DataFrame]:
         """Returns the features as a dictionary of `pd.DataFrame` instances."""
         return {
             feature_type: pd.DataFrame(
@@ -139,7 +138,7 @@ class CompositeFeatureObserver(FeatureObserver):
         }
 
     def initialize_features(self):
-        features: dict[FeatureType, list[NDArray[np.float32]]] = defaultdict(
+        features: Dict[FeatureType, List[NDArray[np.float32]]] = defaultdict(
             list
         )
         for observer in self.feature_observers:

job_shop_lib/dispatching/feature_observers/_earliest_start_time_observer.py

@@ -1,5 +1,7 @@
 """Home of the `EarliestStartTimeObserver` class."""
 
+from typing import List, Optional, Union
+
 import numpy as np
 from numpy.typing import NDArray
 
@@ -75,7 +77,7 @@ class EarliestStartTimeObserver(FeatureObserver):
         dispatcher: Dispatcher,
         *,
         subscribe: bool = True,
-        feature_types: list[FeatureType] | FeatureType | None = None,
+        feature_types: Optional[Union[List[FeatureType], FeatureType]] = None,
     ):
 
         # Earliest start times initialization

job_shop_lib/dispatching/feature_observers/_factory.py

@@ -1,6 +1,7 @@
 """Contains factory functions for creating :class:`FeatureObserver`s."""
 
 from enum import Enum
+from typing import Union, Type
 
 from job_shop_lib.dispatching import DispatcherObserverConfig
 from job_shop_lib.dispatching.feature_observers import (
@@ -36,22 +37,20 @@ class FeatureObserverType(str, Enum):
 
 
 # FeatureObserverConfig = DispatcherObserverConfig[
-#     type[FeatureObserver] | FeatureObserverType | str
+#     Type[FeatureObserver] | FeatureObserverType | str
 # ]
-FeatureObserverConfig = (
-    DispatcherObserverConfig[type[FeatureObserver]]
-    | DispatcherObserverConfig[FeatureObserverType]
-    | DispatcherObserverConfig[str]
-)
+FeatureObserverConfig = DispatcherObserverConfig[
+    Union[Type[FeatureObserver], FeatureObserverType, str]
+]
 
 
 def feature_observer_factory(
-    feature_observer_type: (
-        str
-        | FeatureObserverType
-        | type[FeatureObserver]
-        | FeatureObserverConfig
-    ),
+    feature_observer_type: Union[
+        str,
+        FeatureObserverType,
+        Type[FeatureObserver],
+        FeatureObserverConfig
+    ],
     **kwargs,
 ) -> FeatureObserver:
     """Creates and returns a :class:`FeatureObserver` based on the specified
@@ -73,12 +72,12 @@ def feature_observer_factory(
             **feature_observer_type.kwargs,
             **kwargs,
         )
-    # if the instance is of type type[FeatureObserver] we can just
+    # if the instance is of type Type[FeatureObserver] we can just
     # call the object constructor with the keyword arguments
     if isinstance(feature_observer_type, type):
         return feature_observer_type(**kwargs)
 
-    mapping: dict[FeatureObserverType, type[FeatureObserver]] = {
+    mapping: dict[FeatureObserverType, Type[FeatureObserver]] = {
         FeatureObserverType.IS_READY: IsReadyObserver,
         FeatureObserverType.EARLIEST_START_TIME: EarliestStartTimeObserver,
         FeatureObserverType.DURATION: DurationObserver,

job_shop_lib/dispatching/feature_observers/_feature_observer.py

@@ -1,6 +1,7 @@
 """Home of the `FeatureObserver` class and `FeatureType` enum."""
 
 import enum
+from typing import Optional, Union, Dict, List, Tuple
 
 import numpy as np
 
@@ -64,7 +65,7 @@ class FeatureObserver(DispatcherObserver):
     """
 
     _is_singleton = False
-    _feature_sizes: dict[FeatureType, int] | int = 1
+    _feature_sizes: Union[Dict[FeatureType, int], int] = 1
     _supported_feature_types = list(FeatureType)
 
     __slots__ = {
@@ -84,7 +85,7 @@ class FeatureObserver(DispatcherObserver):
         dispatcher: Dispatcher,
         *,
         subscribe: bool = True,
-        feature_types: list[FeatureType] | FeatureType | None = None,
+        feature_types: Optional[Union[List[FeatureType], FeatureType]] = None,
     ):
         feature_types = self._get_feature_types_list(feature_types)
         if isinstance(self._feature_sizes, int):
@@ -116,7 +117,7 @@ class FeatureObserver(DispatcherObserver):
         self.initialize_features()
 
     @property
-    def feature_sizes(self) -> dict[FeatureType, int]:
+    def feature_sizes(self) -> Dict[FeatureType, int]:
         """Returns the size of the features.
 
         The size of the features is the number of values being observed for
@@ -134,12 +135,12 @@ class FeatureObserver(DispatcherObserver):
         return self._feature_sizes
 
     @property
-    def supported_feature_types(self) -> list[FeatureType]:
+    def supported_feature_types(self) -> List[FeatureType]:
         """Returns the supported feature types."""
         return self._supported_feature_types
 
     @property
-    def feature_dimensions(self) -> dict[FeatureType, tuple[int, int]]:
+    def feature_dimensions(self) -> Dict[FeatureType, Tuple[int, int]]:
         """A dictionary containing the shape of each :class:`FeatureType`."""
         feature_dimensions = {}
         for feature_type, array in self.features.items():
@@ -170,7 +171,7 @@ class FeatureObserver(DispatcherObserver):
         self.initialize_features()
 
     def set_features_to_zero(
-        self, exclude: FeatureType | list[FeatureType] | None = None
+        self, exclude: Optional[Union[FeatureType, List[FeatureType]]] = None
     ):
         """Sets all features to zero except for the ones specified in
         ``exclude``.
@@ -196,8 +197,8 @@ class FeatureObserver(DispatcherObserver):
 
     def _get_feature_types_list(
         self,
-        feature_types: list[FeatureType] | FeatureType | None,
-    ) -> list[FeatureType]:
+        feature_types: Optional[Union[List[FeatureType], FeatureType]],
+    ) -> List[FeatureType]:
         """Returns a list of feature types.
 
         Args:

job_shop_lib/dispatching/feature_observers/_is_completed_observer.py

@@ -1,5 +1,6 @@
 """Home of the `IsCompletedObserver` class."""
 
+from typing import Optional, Union, List
 import numpy as np
 
 from job_shop_lib import ScheduledOperation
@@ -52,7 +53,7 @@ class IsCompletedObserver(FeatureObserver):
         self,
         dispatcher: Dispatcher,
         *,
-        feature_types: list[FeatureType] | FeatureType | None = None,
+        feature_types: Optional[Union[List[FeatureType], FeatureType]] = None,
         subscribe: bool = True,
     ):
         feature_types = self._get_feature_types_list(feature_types)

job_shop_lib/dispatching/feature_observers/_is_ready_observer.py

@@ -1,5 +1,7 @@
 """Home of the `IsReadyObserver` class."""
 
+from typing import List
+
 from job_shop_lib.dispatching.feature_observers import (
     FeatureObserver,
     FeatureType,
@@ -16,7 +18,7 @@ class IsReadyObserver(FeatureObserver):
             feature_ids = self._get_ready_feature_ids(feature_type)
             feature[feature_ids, 0] = 1.0
 
-    def _get_ready_feature_ids(self, feature_type: FeatureType) -> list[int]:
+    def _get_ready_feature_ids(self, feature_type: FeatureType) -> List[int]:
         if feature_type == FeatureType.OPERATIONS:
             return self._get_ready_operations()
         if feature_type == FeatureType.MACHINES:
@@ -28,6 +30,6 @@ class IsReadyObserver(FeatureObserver):
     def reset(self):
         self.initialize_features()
 
-    def _get_ready_operations(self) -> list[int]:
+    def _get_ready_operations(self) -> List[int]:
         available_operations = self.dispatcher.available_operations()
         return [operation.operation_id for operation in available_operations]

job_shop_lib/dispatching/rules/_dispatching_rule_factory.py

@@ -5,6 +5,8 @@ The factory functions create and return the appropriate functions based on the
 specified names or enums.
 """
 
+from typing import Dict, Union
+
 from enum import Enum
 from collections.abc import Callable
 
@@ -31,7 +33,7 @@ class DispatchingRuleType(str, Enum):
 
 
 def dispatching_rule_factory(
-    dispatching_rule: str | DispatchingRuleType,
+    dispatching_rule: Union[str, DispatchingRuleType,]
 ) -> Callable[[Dispatcher], Operation]:
     """Creates and returns a dispatching rule function based on the specified
     dispatching rule name.
@@ -55,7 +57,7 @@ def dispatching_rule_factory(
             If the dispatching_rule argument is not recognized or it is
             not supported.
     """
-    dispatching_rules: dict[
+    dispatching_rules: Dict[
         DispatchingRuleType,
         Callable[[Dispatcher], Operation],
     ] = {

job_shop_lib/dispatching/rules/_dispatching_rule_solver.py

@@ -1,5 +1,6 @@
 """Home of the `DispatchingRuleSolver` class."""
 
+from typing import Optional, Union
 from collections.abc import Callable, Iterable
 
 from job_shop_lib import JobShopInstance, Schedule, Operation, BaseSolver
@@ -65,21 +66,26 @@ class DispatchingRuleSolver(BaseSolver):
 
     def __init__(
         self,
-        dispatching_rule: (
-            str | Callable[[Dispatcher], Operation]
-        ) = DispatchingRuleType.MOST_WORK_REMAINING,
-        machine_chooser: (
-            str | Callable[[Dispatcher, Operation], int]
-        ) = MachineChooserType.FIRST,
-        ready_operations_filter: (
-            Iterable[ReadyOperationsFilter | str | ReadyOperationsFilterType]
-            | str
-            | ReadyOperationsFilterType
-            | ReadyOperationsFilter
-            | None
-        ) = (
+        dispatching_rule: Union[
+            str, Callable[[Dispatcher], Operation]
+        ] = DispatchingRuleType.MOST_WORK_REMAINING,
+        machine_chooser: Union[
+            str, Callable[[Dispatcher, Operation], int]
+        ] = MachineChooserType.FIRST,
+        ready_operations_filter: Optional[
+            Union[
+                Iterable[
+                    Union[
+                        ReadyOperationsFilter, str, ReadyOperationsFilterType
+                    ]
+                ],
+                str,
+                ReadyOperationsFilterType,
+                ReadyOperationsFilter,
+            ]
+        ] = (
             ReadyOperationsFilterType.DOMINATED_OPERATIONS,
-            ReadyOperationsFilterType.NON_IDLE_MACHINES,
+            ReadyOperationsFilterType.NON_IMMEDIATE_OPERATIONS,
         ),
     ):
         if isinstance(dispatching_rule, str):
@@ -100,7 +106,9 @@ class DispatchingRuleSolver(BaseSolver):
         self.ready_operations_filter = ready_operations_filter
 
     def solve(
-        self, instance: JobShopInstance, dispatcher: Dispatcher | None = None
+        self,
+        instance: JobShopInstance,
+        dispatcher: Optional[Dispatcher] = None,
     ) -> Schedule:
         """Returns a schedule for the given job shop instance using the
         dispatching rule algorithm."""

job_shop_lib/dispatching/rules/_dispatching_rules_functions.py

@@ -6,6 +6,7 @@ which operations are selected for execution based on certain criteria such as
 shortest processing time, first come first served, etc.
 """
 
+from typing import List, Optional
 from collections.abc import Callable, Sequence
 import random
 
@@ -88,7 +89,7 @@ def score_based_rule(
 
 
 def score_based_rule_with_tie_breaker(
-    score_functions: list[Callable[[Dispatcher], Sequence[int]]],
+    score_functions: List[Callable[[Dispatcher], Sequence[int]]],
 ) -> Callable[[Dispatcher], Operation]:
     """Creates a dispatching rule based on multiple scoring functions.
 
@@ -122,7 +123,7 @@ def score_based_rule_with_tie_breaker(
 # -----------------
 
 
-def shortest_processing_time_score(dispatcher: Dispatcher) -> list[int]:
+def shortest_processing_time_score(dispatcher: Dispatcher) -> List[int]:
     """Scores each job based on the duration of the next operation."""
     num_jobs = dispatcher.instance.num_jobs
     scores = [0] * num_jobs
@@ -131,7 +132,7 @@ def shortest_processing_time_score(dispatcher: Dispatcher) -> list[int]:
     return scores
 
 
-def first_come_first_served_score(dispatcher: Dispatcher) -> list[int]:
+def first_come_first_served_score(dispatcher: Dispatcher) -> List[int]:
     """Scores each job based on the position of the next operation."""
     num_jobs = dispatcher.instance.num_jobs
     scores = [0] * num_jobs
@@ -153,9 +154,9 @@ class MostWorkRemainingScorer:  # pylint: disable=too-few-public-methods
     """
 
     def __init__(self) -> None:
-        self._duration_observer: DurationObserver | None = None
-        self._is_ready_observer: IsReadyObserver | None = None
-        self._current_dispatcher: Dispatcher | None = None
+        self._duration_observer: Optional[DurationObserver] = None
+        self._is_ready_observer: Optional[IsReadyObserver] = None
+        self._current_dispatcher: Optional[Dispatcher] = None
 
     def __call__(self, dispatcher: Dispatcher) -> Sequence[int]:
         """Scores each job based on the remaining work in the job."""
@@ -197,7 +198,7 @@ observer_based_most_work_remaining_rule = score_based_rule(
 )
 
 
-def most_operations_remaining_score(dispatcher: Dispatcher) -> list[int]:
+def most_operations_remaining_score(dispatcher: Dispatcher) -> List[int]:
     """Scores each job based on the remaining operations in the job."""
     num_jobs = dispatcher.instance.num_jobs
     scores = [0] * num_jobs
@@ -206,7 +207,7 @@ def most_operations_remaining_score(dispatcher: Dispatcher) -> list[int]:
     return scores
 
 
-def random_score(dispatcher: Dispatcher) -> list[int]:
+def random_score(dispatcher: Dispatcher) -> List[int]:
     """Scores each job randomly."""
     return [
         random.randint(0, 100) for _ in range(dispatcher.instance.num_jobs)

job_shop_lib/dispatching/rules/_machine_chooser_factory.py

@@ -5,6 +5,7 @@ The factory functions create and return the appropriate functions based on the
 specified names or enums.
 """
 
+from typing import Union, Dict
 from enum import Enum
 from collections.abc import Callable
 import random
@@ -25,7 +26,7 @@ MachineChooser = Callable[[Dispatcher, Operation], int]
 
 
 def machine_chooser_factory(
-    machine_chooser: str | MachineChooser,
+    machine_chooser: Union[str, MachineChooser],
 ) -> MachineChooser:
     """Creates and returns a machine chooser function based on the specified
     machine chooser strategy name.
@@ -36,7 +37,7 @@ def machine_chooser_factory(
     machine randomly.
 
     Args:
-        machine_chooser (str): The name of the machine chooser strategy to be
+        machine_chooser: The name of the machine chooser strategy to be
             used. Supported values are 'first' and 'random'.
 
     Returns:
@@ -49,7 +50,7 @@ def machine_chooser_factory(
         ValueError: If the machine_chooser argument is not recognized or is
             not supported.
     """
-    machine_choosers: dict[str, Callable[[Dispatcher, Operation], int]] = {
+    machine_choosers: Dict[str, Callable[[Dispatcher, Operation], int]] = {
         MachineChooserType.FIRST: lambda _, operation: operation.machines[0],
         MachineChooserType.RANDOM: lambda _, operation: random.choice(
             operation.machines

job_shop_lib/dispatching/rules/_utils.py

@@ -1,5 +1,6 @@
 """Utility functions."""
 
+from typing import Union, List
 import time
 from collections.abc import Callable
 import pandas as pd
@@ -10,12 +11,12 @@ from job_shop_lib.dispatching import Dispatcher
 
 
 def benchmark_dispatching_rules(
-    dispatching_rules: (
-        list[str | Callable[[Dispatcher], Operation]]
-        | list[str]
-        | list[Callable[[Dispatcher], Operation]]
-    ),
-    instances: list[JobShopInstance],
+    dispatching_rules: Union[
+        List[Union[str, Callable[[Dispatcher], Operation]]],
+        List[str],
+        List[Callable[[Dispatcher], Operation]]
+    ],
+    instances: List[JobShopInstance],
 ) -> pd.DataFrame:
     """Benchmark multiple dispatching rules on multiple JobShopInstances.
 
@@ -30,7 +31,7 @@ def benchmark_dispatching_rules(
             either a string (name of a built-in rule) or a callable
             (custom rule function).
         instances:
-             iList of :class:`JobShopInstance` objects to be solved.
+            List of :class:`JobShopInstance` objects to be solved.
 
     Returns:
         A pandas DataFrame with columns:
@@ -111,7 +112,7 @@ if __name__ == "__main__":
     instances_ = [load_benchmark_instance(f"ta{i:02d}") for i in range(1, 3)]
 
     # Define rules
-    rules_: list[str | Callable[[Dispatcher], Operation]] = [
+    rules_: List[str | Callable[[Dispatcher], Operation]] = [
         "most_work_remaining",
         "shortest_processing_time",
         most_work_remaining_rule,

job_shop_lib/generation/__init__.py

@@ -1,5 +1,10 @@
 """Package for generating job shop instances."""
 
+from job_shop_lib.generation._utils import (
+    generate_duration_matrix,
+    generate_machine_matrix_with_recirculation,
+    generate_machine_matrix_without_recirculation,
+)
 from job_shop_lib.generation._instance_generator import InstanceGenerator
 from job_shop_lib.generation._general_instance_generator import (
     GeneralInstanceGenerator,
@@ -8,4 +13,7 @@ from job_shop_lib.generation._general_instance_generator import (
 __all__ = [
     "InstanceGenerator",
     "GeneralInstanceGenerator",
+    "generate_duration_matrix",
+    "generate_machine_matrix_with_recirculation",
+    "generate_machine_matrix_without_recirculation",
 ]