job-shop-lib 1.0.0a2__py3-none-any.whl → 1.0.0a3__py3-none-any.whl

job_shop_lib/_job_shop_instance.py

@@ -20,15 +20,27 @@ class JobShopInstance:
     computations.
 
     Attributes:
-        jobs:
+        jobs (list[list[Operation]]):
             A list of lists of operations. Each list of operations represents
             a job, and the operations are ordered by their position in the job.
             The `job_id`, `position_in_job`, and `operation_id` attributes of
             the operations are set when the instance is created.
-        name:
+        name (str):
             A string with the name of the instance.
-        metadata:
+        metadata (dict[str, Any]):
             A dictionary with additional information about the instance.
+
+    Args:
+        jobs:
+            A list of lists of operations. Each list of operations
+            represents a job, and the operations are ordered by their
+            position in the job. The `job_id`, `position_in_job`, and
+            `operation_id` attributes of the operations are set when the
+            instance is created.
+        name:
+            A string with the name of the instance.
+        **metadata:
+            Additional information about the instance.
     """
 
     def __init__(
@@ -37,24 +49,10 @@ class JobShopInstance:
         name: str = "JobShopInstance",
         **metadata: Any,
     ):
-        """Initializes the instance based on a list of lists of operations.
-
-        Args:
-            jobs:
-                A list of lists of operations. Each list of operations
-                represents a job, and the operations are ordered by their
-                position in the job. The `job_id`, `position_in_job`, and
-                `operation_id` attributes of the operations are set when the
-                instance is created.
-            name:
-                A string with the name of the instance.
-            **metadata:
-                Additional information about the instance.
-        """
-        self.jobs = jobs
+        self.jobs: list[list[Operation]] = jobs
         self.set_operation_attributes()
-        self.name = name
-        self.metadata = metadata
+        self.name: str = name
+        self.metadata: dict[str, Any] = metadata
 
     def set_operation_attributes(self):
         """Sets the job_id and position of each operation."""

job_shop_lib/_operation.py

@@ -51,8 +51,10 @@ class Operation:
     }
 
     def __init__(self, machines: int | list[int], duration: int):
-        self.machines = [machines] if isinstance(machines, int) else machines
-        self.duration = duration
+        self.machines: list[int] = (
+            [machines] if isinstance(machines, int) else machines
+        )
+        self.duration: int = duration
 
         # Defined outside the class by the JobShopInstance class:
         self.job_id: int = -1
@@ -64,8 +66,8 @@ class Operation:
         """Returns the id of the machine associated with the operation.
 
         Raises:
-            UninitializedAttributeError: If the operation has multiple machines
-            in its list.
+            UninitializedAttributeError:
+                If the operation has multiple machines in its list.
         """
         if len(self.machines) > 1:
             raise UninitializedAttributeError(

job_shop_lib/_schedule.py

@@ -46,7 +46,7 @@ class Schedule:
         self,
         instance: JobShopInstance,
         schedule: list[list[ScheduledOperation]] | None = None,
-        **metadata,
+        **metadata: Any,
     ):
         """Initializes the object with the given instance and schedule.
 
@@ -65,9 +65,9 @@ class Schedule:
 
         Schedule.check_schedule(schedule)
 
-        self.instance = instance
+        self.instance: JobShopInstance = instance
         self._schedule = schedule
-        self.metadata = metadata
+        self.metadata: dict[str, Any] = metadata
 
     def __repr__(self) -> str:
         return str(self.schedule)

job_shop_lib/_scheduled_operation.py

@@ -31,8 +31,8 @@ class ScheduledOperation:
                 If the given machine_id is not in the list of valid machines
                 for the operation.
         """
-        self.operation = operation
-        self.start_time = start_time
+        self.operation: Operation = operation
+        self.start_time: int = start_time
         self._machine_id = machine_id
         self.machine_id = machine_id  # Validate machine_id
 

job_shop_lib/dispatching/__init__.py

@@ -32,6 +32,8 @@ from ._ready_operation_filters import (
     filter_dominated_operations,
     filter_non_immediate_machines,
     ReadyOperationsFilter,
+    filter_non_idle_machines,
+    filter_non_immediate_operations,
 )
 from ._dispatcher_observer_config import DispatcherObserverConfig
 from ._factories import (
@@ -53,4 +55,6 @@ __all__ = [
     "DispatcherObserverConfig",
     "UnscheduledOperationsObserver",
     "ReadyOperationsFilter",
+    "filter_non_idle_machines",
+    "filter_non_immediate_operations",
 ]

job_shop_lib/dispatching/_dispatcher.py

@@ -156,26 +156,30 @@ class Dispatcher:
     responsible for scheduling the operations on the machines and keeping
     track of the next available time for each machine and job.
 
-    Attributes:
+    Args:
         instance:
-            The instance of the job shop problem to be scheduled.
-        schedule:
-            The schedule of operations on machines.
+            The instance of the job shop problem to be solved.
         ready_operations_filter:
-            A function that filters out operations that are not ready to be
-            scheduled.
+            A function that filters out operations that are not ready to
+            be scheduled. The function should take the dispatcher and a
+            list of operations as input and return a list of operations
+            that are ready to be scheduled. If ``None``, no filtering is
+            done.
     """
 
-    __slots__ = (
-        "instance",
-        "schedule",
-        "_machine_next_available_time",
-        "_job_next_operation_index",
-        "_job_next_available_time",
-        "ready_operations_filter",
-        "subscribers",
-        "_cache",
-    )
+    __slots__ = {
+        "instance": "The instance of the job shop problem to be scheduled.",
+        "schedule": "The schedule of operations on machines.",
+        "_machine_next_available_time": "",
+        "_job_next_operation_index": "",
+        "_job_next_available_time": "",
+        "ready_operations_filter": (
+            "A function that filters out operations that are not ready to be "
+            "scheduled."
+        ),
+        "subscribers": "A list of observers subscribed to the dispatcher.",
+        "_cache": "A dictionary to cache the results of the cached methods.",
+    }
 
     def __init__(
         self,
@@ -184,18 +188,6 @@ class Dispatcher:
             Callable[[Dispatcher, list[Operation]], list[Operation]] | None
         ) = None,
     ) -> None:
-        """Initializes the object with the given instance.
-
-        Args:
-            instance:
-                The instance of the job shop problem to be solved.
-            ready_operations_filter:
-                A function that filters out operations that are not ready to
-                be scheduled. The function should take the dispatcher and a
-                list of operations as input and return a list of operations
-                that are ready to be scheduled. If ``None``, no filtering is
-                done.
-        """
 
         self.instance = instance
         self.schedule = Schedule(self.instance)
@@ -371,7 +363,7 @@ class Dispatcher:
         The current time is the minimum start time of the available
         operations.
         """
-        available_operations = self.ready_operations()
+        available_operations = self.available_operations()
         current_time = self.min_start_time(available_operations)
         return current_time
 
@@ -387,7 +379,7 @@ class Dispatcher:
         return int(min_start_time)
 
     @_dispatcher_cache
-    def ready_operations(self) -> list[Operation]:
+    def available_operations(self) -> list[Operation]:
         """Returns a list of available operations for processing, optionally
         filtering out operations using the filter function.
 
@@ -443,7 +435,7 @@ class Dispatcher:
     @_dispatcher_cache
     def available_machines(self) -> list[int]:
         """Returns the list of ready machines."""
-        available_operations = self.ready_operations()
+        available_operations = self.available_operations()
         available_machines = set()
         for operation in available_operations:
             available_machines.update(operation.machines)
@@ -452,7 +444,7 @@ class Dispatcher:
     @_dispatcher_cache
     def available_jobs(self) -> list[int]:
         """Returns the list of ready jobs."""
-        available_operations = self.ready_operations()
+        available_operations = self.available_operations()
         available_jobs = set(
             operation.job_id for operation in available_operations
         )

job_shop_lib/dispatching/_factories.py

@@ -13,6 +13,8 @@ from job_shop_lib.dispatching import (
     Dispatcher,
     filter_dominated_operations,
     filter_non_immediate_machines,
+    filter_non_idle_machines,
+    filter_non_immediate_operations,
     ReadyOperationsFilter,
 )
 
@@ -27,6 +29,8 @@ class ReadyOperationsFilterType(str, Enum):
 
     DOMINATED_OPERATIONS = "dominated_operations"
     NON_IMMEDIATE_MACHINES = "non_immediate_machines"
+    NON_IDLE_MACHINES = "non_idle_machines"
+    NON_IMMEDIATE_OPERATIONS = "non_immediate_operations"
 
 
 def create_composite_operation_filter(
@@ -114,6 +118,10 @@ def ready_operations_filter_factory(
         ReadyOperationsFilterType.NON_IMMEDIATE_MACHINES: (
             filter_non_immediate_machines
         ),
+        ReadyOperationsFilterType.NON_IDLE_MACHINES: filter_non_idle_machines,
+        ReadyOperationsFilterType.NON_IMMEDIATE_OPERATIONS: (
+            filter_non_immediate_operations
+        ),
     }
 
     if filter_name not in filtering_strategies:

job_shop_lib/dispatching/_ready_operation_filters.py

@@ -15,6 +15,86 @@ ReadyOperationsFilter = Callable[
 ]
 
 
+def filter_non_idle_machines(
+    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
+    currently scheduled on it. This filter removes operations that are
+    associated with machines that are busy (i.e., have at least one
+    uncompleted operation).
+
+    Utilizes :meth:``Dispatcher.ongoing_operations()`` to determine machine
+    statuses.
+
+    Args:
+        dispatcher: The dispatcher object.
+        operations: The list of operations to filter.
+
+    Returns:
+        The list of operations that are associated with idle machines.
+    """
+    current_time = dispatcher.min_start_time(operations)
+    non_idle_machines = _get_non_idle_machines(dispatcher, current_time)
+
+    # Filter operations to keep those that are associated with at least one
+    # idle machine
+    filtered_operations: list[Operation] = []
+    for operation in operations:
+        if all(
+            machine_id in non_idle_machines
+            for machine_id in operation.machines
+        ):
+            continue
+        filtered_operations.append(operation)
+
+    return filtered_operations
+
+
+def _get_non_idle_machines(
+    dispatcher: Dispatcher, current_time: int
+) -> set[int]:
+    """Returns the set of machine ids that are currently busy (i.e., have at
+    least one uncompleted operation)."""
+
+    non_idle_machines = set()
+    for machine_schedule in dispatcher.schedule.schedule:
+        for scheduled_operation in reversed(machine_schedule):
+            is_completed = scheduled_operation.end_time <= current_time
+            if is_completed:
+                break
+            non_idle_machines.add(scheduled_operation.machine_id)
+
+    return non_idle_machines
+
+
+def filter_non_immediate_operations(
+    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
+    current time.
+
+    The current time is determined by the minimum start time of the
+    operations.
+
+    Args:
+        dispatcher: The dispatcher object.
+        operations: The list of operations to filter.
+    """
+
+    min_start_time = dispatcher.min_start_time(operations)
+    immediate_operations: list[Operation] = []
+    for operation in operations:
+        start_time = dispatcher.earliest_start_time(operation)
+        if start_time == min_start_time:
+            immediate_operations.append(operation)
+
+    return immediate_operations
+
+
 def filter_dominated_operations(
     dispatcher: Dispatcher, operations: list[Operation]
 ) -> list[Operation]:

job_shop_lib/dispatching/feature_observers/_is_ready_observer.py

@@ -29,5 +29,5 @@ class IsReadyObserver(FeatureObserver):
         self.initialize_features()
 
     def _get_ready_operations(self) -> list[int]:
-        available_operations = self.dispatcher.ready_operations()
+        available_operations = self.dispatcher.available_operations()
         return [operation.operation_id for operation in available_operations]

job_shop_lib/dispatching/rules/_dispatching_rule_solver.py

@@ -1,12 +1,14 @@
 """Home of the `DispatchingRuleSolver` class."""
 
-from collections.abc import Callable
+from collections.abc import Callable, Iterable
 
 from job_shop_lib import JobShopInstance, Schedule, Operation, BaseSolver
 from job_shop_lib.dispatching import (
     ready_operations_filter_factory,
     Dispatcher,
     ReadyOperationsFilterType,
+    ReadyOperationsFilter,
+    create_composite_operation_filter,
 )
 from job_shop_lib.dispatching.rules import (
     dispatching_rule_factory,
@@ -30,6 +32,35 @@ class DispatchingRuleSolver(BaseSolver):
         pruning_function:
             The pruning function to use. It is used to initialize the
             dispatcher object internally when calling the solve method.
+
+    Args:
+        dispatching_rule:
+            The dispatching rule to use. It can be a string with the name
+            of the dispatching rule, a class`DispatchingRuleType` enum member,
+            or a callable that takes a dispatcher and returns the operation to
+            be dispatched next.
+        machine_chooser:
+            The machine chooser to use. It can be a string with the name
+            of the machine chooser, a :class:`MachineChooserType` member, or a
+            callable that takes a dispatcher and an operation and returns
+            the machine id where the operation will be dispatched.
+        ready_operations_filter:
+            The ready operations filter to use. It can be either:
+
+            - a string with the name of the pruning function
+            - a :class`ReadyOperationsFilterType` enum member.
+            - a callable that takes a dispatcher and a list of operations
+              and returns a list of operations that should be considered
+              for dispatching,
+            - a list with names or actual ready operations filters to be used.
+              If a list is provided, a composite filter will be created
+              using the specified filters.
+    
+    .. seealso::
+        - :func:`job_shop_lib.dispatching.rules.dispatching_rule_factory`
+        - :func:`job_shop_lib.dispatching.rules.machine_chooser_factory`
+        - :func:`~job_shop_lib.dispatching.ready_operations_filter_factory`
+        - :func:`~job_shop_lib.dispatching.create_composite_operation_filter`
     """
 
     def __init__(
@@ -41,32 +72,16 @@ class DispatchingRuleSolver(BaseSolver):
             str | Callable[[Dispatcher, Operation], int]
         ) = MachineChooserType.FIRST,
         ready_operations_filter: (
-            str
-            | Callable[[Dispatcher, list[Operation]], list[Operation]]
+            Iterable[ReadyOperationsFilter | str | ReadyOperationsFilterType]
+            | str
+            | ReadyOperationsFilterType
+            | ReadyOperationsFilter
             | None
-        ) = ReadyOperationsFilterType.DOMINATED_OPERATIONS,
+        ) = (
+            ReadyOperationsFilterType.DOMINATED_OPERATIONS,
+            ReadyOperationsFilterType.NON_IDLE_MACHINES,
+        ),
     ):
-        """Initializes the solver with the given dispatching rule, machine
-        chooser and pruning function.
-
-        Args:
-            dispatching_rule:
-                The dispatching rule to use. It can be a string with the name
-                of the dispatching rule, a DispatchingRule enum member, or a
-                callable that takes a dispatcher and returns the operation to
-                be dispatched next.
-            machine_chooser:
-                The machine chooser to use. It can be a string with the name
-                of the machine chooser, a MachineChooser enum member, or a
-                callable that takes a dispatcher and an operation and returns
-                the machine id where the operation will be dispatched.
-            ready_operations_filter:
-                The ready operations filter to use. It can be a string with
-                the name of the pruning function, a PruningFunction enum
-                member, or a callable that takes a dispatcher and a list of
-                operations and returns a list of operations that should be
-                considered for dispatching.
-        """
         if isinstance(dispatching_rule, str):
             dispatching_rule = dispatching_rule_factory(dispatching_rule)
         if isinstance(machine_chooser, str):
@@ -75,6 +90,10 @@ class DispatchingRuleSolver(BaseSolver):
             ready_operations_filter = ready_operations_filter_factory(
                 ready_operations_filter
             )
+        if isinstance(ready_operations_filter, Iterable):
+            ready_operations_filter = create_composite_operation_filter(
+                ready_operations_filter
+            )
 
         self.dispatching_rule = dispatching_rule
         self.machine_chooser = machine_chooser

job_shop_lib/dispatching/rules/_dispatching_rules_functions.py

@@ -21,7 +21,7 @@ from job_shop_lib.dispatching.feature_observers import (
 def shortest_processing_time_rule(dispatcher: Dispatcher) -> Operation:
     """Dispatches the operation with the shortest duration."""
     return min(
-        dispatcher.ready_operations(),
+        dispatcher.available_operations(),
         key=lambda operation: operation.duration,
     )
 
@@ -29,7 +29,7 @@ def shortest_processing_time_rule(dispatcher: Dispatcher) -> Operation:
 def first_come_first_served_rule(dispatcher: Dispatcher) -> Operation:
     """Dispatches the operation with the lowest position in job."""
     return min(
-        dispatcher.ready_operations(),
+        dispatcher.available_operations(),
         key=lambda operation: operation.position_in_job,
     )
 
@@ -41,7 +41,7 @@ def most_work_remaining_rule(dispatcher: Dispatcher) -> Operation:
         job_remaining_work[operation.job_id] += operation.duration
 
     return max(
-        dispatcher.ready_operations(),
+        dispatcher.available_operations(),
         key=lambda operation: job_remaining_work[operation.job_id],
     )
 
@@ -53,14 +53,14 @@ def most_operations_remaining_rule(dispatcher: Dispatcher) -> Operation:
         job_remaining_operations[operation.job_id] += 1
 
     return max(
-        dispatcher.ready_operations(),
+        dispatcher.available_operations(),
         key=lambda operation: job_remaining_operations[operation.job_id],
     )
 
 
 def random_operation_rule(dispatcher: Dispatcher) -> Operation:
     """Dispatches a random operation."""
-    return random.choice(dispatcher.ready_operations())
+    return random.choice(dispatcher.available_operations())
 
 
 def score_based_rule(
@@ -80,7 +80,7 @@ def score_based_rule(
     def rule(dispatcher: Dispatcher) -> Operation:
         scores = score_function(dispatcher)
         return max(
-            dispatcher.ready_operations(),
+            dispatcher.available_operations(),
             key=lambda operation: scores[operation.job_id],
         )
 
@@ -102,7 +102,7 @@ def score_based_rule_with_tie_breaker(
     """
 
     def rule(dispatcher: Dispatcher) -> Operation:
-        candidates = dispatcher.ready_operations()
+        candidates = dispatcher.available_operations()
         for scoring_function in score_functions:
             scores = scoring_function(dispatcher)
             best_score = max(scores)
@@ -126,7 +126,7 @@ 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
-    for operation in dispatcher.ready_operations():
+    for operation in dispatcher.available_operations():
         scores[operation.job_id] = -operation.duration
     return scores
 
@@ -135,7 +135,7 @@ 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
-    for operation in dispatcher.ready_operations():
+    for operation in dispatcher.available_operations():
         scores[operation.job_id] = operation.operation_id
     return scores
 

job_shop_lib/reinforcement_learning/_single_job_shop_graph_env.py

@@ -260,7 +260,7 @@ class SingleJobShopGraphEnv(gym.Env):
         truncated = False
         info: dict[str, Any] = {
             "feature_names": self.composite_observer.column_names,
-            "available_operations": self.dispatcher.ready_operations(),
+            "available_operations": self.dispatcher.available_operations(),
         }
         return obs, reward, done, truncated, info
 

job_shop_lib/visualization/__init__.py

@@ -1,11 +1,11 @@
 """Package for visualization."""
 
-from job_shop_lib.visualization._gantt_chart import plot_gantt_chart
+from job_shop_lib.visualization._plot_gantt_chart import plot_gantt_chart
 from job_shop_lib.visualization._gantt_chart_video_and_gif_creation import (
-    create_gif,
+    create_gantt_chart_gif,
     create_gantt_chart_video,
     create_gantt_chart_frames,
-    plot_gantt_chart_wrapper,
+    get_partial_gantt_chart_plotter,
     create_video_from_frames,
     create_gif_from_frames,
 )
@@ -26,9 +26,9 @@ from job_shop_lib.visualization._gantt_chart_creator import (
 __all__ = [
     "plot_gantt_chart",
     "create_gantt_chart_video",
-    "create_gif",
+    "create_gantt_chart_gif",
     "create_gantt_chart_frames",
-    "plot_gantt_chart_wrapper",
+    "get_partial_gantt_chart_plotter",
     "create_gif_from_frames",
     "create_video_from_frames",
     "plot_disjunctive_graph",

job_shop_lib/visualization/_gantt_chart_creator.py

@@ -10,8 +10,8 @@ from job_shop_lib.dispatching import (
 )
 from job_shop_lib.visualization import (
     create_gantt_chart_video,
-    plot_gantt_chart_wrapper,
-    create_gif,
+    get_partial_gantt_chart_plotter,
+    create_gantt_chart_gif,
 )
 
 
@@ -146,7 +146,7 @@ class GanttChartCreator:
         self.history_observer: HistoryObserver = (
             dispatcher.create_or_get_observer(HistoryObserver)
         )
-        self.plot_function = plot_gantt_chart_wrapper(
+        self.plot_function = get_partial_gantt_chart_plotter(
             **self.gannt_chart_wrapper_config
         )
 
@@ -175,7 +175,7 @@ class GanttChartCreator:
         return self.plot_function(
             self.schedule,
             None,
-            self.dispatcher.ready_operations(),
+            self.dispatcher.available_operations(),
             self.dispatcher.current_time(),
         )
 
@@ -196,7 +196,7 @@ class GanttChartCreator:
         The configuration for the GIF creation can be customized through the
         `gif_config` attribute.
         """
-        create_gif(
+        create_gantt_chart_gif(
             instance=self.history_observer.dispatcher.instance,
             schedule_history=self.history_observer.history,
             plot_function=self.plot_function,

job_shop_lib/visualization/_gantt_chart_video_and_gif_creation.py

@@ -3,8 +3,7 @@
 import os
 import pathlib
 import shutil
-from collections.abc import Callable
-from typing import Sequence
+from typing import Sequence, Protocol
 
 import imageio
 import matplotlib.pyplot as plt
@@ -23,19 +22,49 @@ from job_shop_lib.dispatching import (
     HistoryObserver,
 )
 from job_shop_lib.dispatching.rules import DispatchingRuleSolver
-from job_shop_lib.visualization._gantt_chart import plot_gantt_chart
-
+from job_shop_lib.visualization._plot_gantt_chart import plot_gantt_chart
+
+
+# This class serves as a more meaningful type hint than simply:
+# PlotFunction = Callable[
+#     [Schedule, int | None, list[Operation] | None, int | None], Figure
+# ]
+# That's why it doesn't have more methods or attributes. It is a protocol
+# for functions, not for classes.
+# pylint: disable=too-few-public-methods
+class PartialGanttChartPlotter(Protocol):
+    """A protocol for a function that plots an uncompleted Gantt chart
+    for a schedule.
+
+    This kind of functions are created using the
+    :func:`plot_gantt_chart_wrapper` function.
+
+    The function should take the following arguments:
+
+    - schedule: The schedule to plot.
+    - makespan: The makespan of the schedule if known. Can be used to fix the
+      x-axis limits.
+    - available_operations: A list of available operations. If ``None``,
+      the available operations are not shown.
+    - current_time: The current time in the schedule. If provided, a red
+      vertical line is plotted at this time.
+    """
 
-PlotFunction = Callable[
-    [Schedule, int | None, list[Operation] | None, int | None], Figure
-]
+    def __call__(
+        self,
+        schedule: Schedule,
+        makespan: int | None = None,
+        available_operations: list[Operation] | None = None,
+        current_time: int | None = None,
+    ) -> Figure:
+        pass
 
 
-def plot_gantt_chart_wrapper(
+def get_partial_gantt_chart_plotter(
     title: str | None = None,
     cmap: str = "viridis",
     show_available_operations: bool = False,
-) -> PlotFunction:
+) -> PartialGanttChartPlotter:
     """Returns a function that plots a Gantt chart for an unfinished schedule.
 
     Args:
@@ -47,12 +76,13 @@ def plot_gantt_chart_wrapper(
     Returns:
         A function that plots a Gantt chart for a schedule. The function takes
         the following arguments:
+
         - schedule: The schedule to plot.
         - makespan: The makespan of the schedule.
         - available_operations: A list of available operations. If None,
-            the available operations are not shown.
+          the available operations are not shown.
         - current_time: The current time in the schedule. If provided, a
-            red vertical line is plotted at this time.
+          red vertical line is plotted at this time.
 
     """
 
@@ -97,33 +127,30 @@ def plot_gantt_chart_wrapper(
 # Most of the arguments are optional with default values. There is no way to
 # reduce the number of arguments without losing functionality.
 # pylint: disable=too-many-arguments
-def create_gif(
-    gif_path: str | None,
+def create_gantt_chart_gif(
     instance: JobShopInstance,
+    gif_path: str | None = None,
     solver: DispatchingRuleSolver | None = None,
-    plot_function: PlotFunction | None = None,
+    plot_function: PartialGanttChartPlotter | None = None,
     fps: int = 1,
     remove_frames: bool = True,
     frames_dir: str | None = None,
     plot_current_time: bool = True,
     schedule_history: Sequence[ScheduledOperation] | None = None,
 ) -> None:
-    """Creates a GIF of the schedule being built by the given solver.
-
-    Deprecated since version 0.6.0: Use `create_gif_or_video` instead.
+    """Creates a GIF of the schedule being built.
 
     Args:
-        gif_path:
-            The path to save the GIF file. It should end with ".gif". If not
-            provided, the name of the instance is used. It will be made an
-            optional argument in version 1.0.0.
         instance:
             The instance of the job shop problem to be scheduled.
+        gif_path:
+            The path to save the GIF file. It should end with ".gif". If not
+            provided, the name of the instance is used.
         solver:
             The dispatching rule solver to use. If not provided, the history
             of scheduled operations should be provided.
         plot_function:
-            A function that plots a Gantt chart for a schedule. It
+            A :class:`PlotFunction` that plots a Gantt chart for a schedule. It
             should take a `Schedule` object and the makespan of the schedule as
             input and return a `Figure` object. If not provided, a default
             function is used.
@@ -133,7 +160,7 @@ def create_gif(
             Whether to remove the frames after creating the GIF.
         frames_dir:
             The directory to save the frames in. If not provided,
-            `gif_path.replace(".gif", "") + "_frames"` is used.
+            ``gif_path.replace(".gif", "") + "_frames"`` is used.
         plot_current_time:
             Whether to plot a vertical line at the current time.
         schedule_history:
@@ -144,7 +171,7 @@ def create_gif(
         gif_path = f"{instance.name}_gantt_chart.gif"
 
     if plot_function is None:
-        plot_function = plot_gantt_chart_wrapper()
+        plot_function = get_partial_gantt_chart_plotter()
 
     if frames_dir is None:
         # Use the name of the GIF file as the directory name
@@ -173,14 +200,14 @@ def create_gantt_chart_video(
     instance: JobShopInstance,
     video_path: str | None = None,
     solver: DispatchingRuleSolver | None = None,
-    plot_function: PlotFunction | None = None,
+    plot_function: PartialGanttChartPlotter | None = None,
     fps: int = 1,
     remove_frames: bool = True,
     frames_dir: str | None = None,
     plot_current_time: bool = True,
     schedule_history: Sequence[ScheduledOperation] | None = None,
 ) -> None:
-    """Creates a GIF of the schedule being built by the given solver.
+    """Creates a video of the schedule being built.
 
     Args:
         instance:
@@ -192,16 +219,16 @@ def create_gantt_chart_video(
             of scheduled operations should be provided.
         plot_function:
             A function that plots a Gantt chart for a schedule. It
-            should take a `Schedule` object and the makespan of the schedule as
-            input and return a `Figure` object. If not provided, a default
-            function is used.
+            should take a :class:`Schedule` object and the makespan of the
+            schedule as input and return a ``Figure`` object. If not provided,
+            a default function is used.
         fps:
-            The number of frames per second in the GIF.
+            The number of frames per second in the video.
         remove_frames:
-            Whether to remove the frames after creating the GIF.
+            Whether to remove the frames after creating the video.
         frames_dir:
             The directory to save the frames in. If not provided,
-            `name_without_the_extension` + "_frames"` is used.
+            ``name_without_the_extension + "_frames"`` is used.
         plot_current_time:
             Whether to plot a vertical line at the current time.
         schedule_history:
@@ -212,7 +239,7 @@ def create_gantt_chart_video(
         video_path = f"{instance.name}_gantt_chart.mp4"
 
     if plot_function is None:
-        plot_function = plot_gantt_chart_wrapper()
+        plot_function = get_partial_gantt_chart_plotter()
 
     if frames_dir is None:
         extension = video_path.split(".")[-1]
@@ -238,7 +265,7 @@ def create_gantt_chart_frames(
     frames_dir: str,
     instance: JobShopInstance,
     solver: DispatchingRuleSolver | None,
-    plot_function: PlotFunction,
+    plot_function: PartialGanttChartPlotter,
     plot_current_time: bool = True,
     schedule_history: Sequence[ScheduledOperation] | None = None,
 ) -> None:
@@ -295,7 +322,7 @@ def create_gantt_chart_frames(
         fig = plot_function(
             dispatcher.schedule,
             makespan,
-            dispatcher.ready_operations(),
+            dispatcher.available_operations(),
             current_time,
         )
         _save_frame(fig, frames_dir, i)

job_shop_lib/visualization/{_gantt_chart.py → _plot_gantt_chart.py}

@@ -20,16 +20,39 @@ def plot_gantt_chart(
     cmap_name: str = "viridis",
     xlim: int | None = None,
     number_of_x_ticks: int = 15,
+    job_labels: None | list[str] = None,
+    machine_labels: None | list[str] = None,
+    legend_title: str = "",
+    x_label: str = "Time units",
+    y_label: str = "Machines",
 ) -> tuple[Figure, plt.Axes]:
     """Plots a Gantt chart for the schedule.
 
+    This function generates a Gantt chart that visualizes the schedule of jobs
+    across multiple machines. Each job is represented with a unique color,
+    and operations are plotted as bars on the corresponding machines over time.
+
+    The Gantt chart helps to understand the flow of jobs on machines and
+    visualize the makespan of the schedule, i.e., the time it takes to
+    complete all jobs.
+
+    The Gantt chart includes:
+
+    - X-axis: Time units, representing the progression of the schedule.
+    - Y-axis: Machines, which are assigned jobs at various time slots.
+    - Legend: A list of jobs, labeled and color-coded for clarity.
+
+    .. note::
+        The last tick on the x-axis always represents the makespan for easy
+        identification of the completion time.
+
     Args:
         schedule:
             The schedule to plot.
         title:
             The title of the plot. If not provided, the title:
-            `f"Gantt Chart for {schedule.instance.name} instance"`
-            is used.
+            ``f"Gantt Chart for {schedule.instance.name} instance"``
+            is used. To remove the title, provide an empty string.
         cmap_name:
             The name of the colormap to use. Default is "viridis".
         xlim:
@@ -37,21 +60,45 @@ def plot_gantt_chart(
             the schedule is used.
         number_of_x_ticks:
             The number of ticks to use in the x-axis.
+        job_labels:
+            A list of labels for each job. If ``None``, the labels are
+            automatically generated as "Job 0", "Job 1", etc.
+        machine_labels:
+            A list of labels for each machine. If ``None``, the labels are
+            automatically generated as "0", "1", etc.
+        legend_title:
+            The title of the legend. If not provided, the legend will not have
+            a title.
+        x_label:
+            The label for the x-axis. Default is "Time units". To remove the
+            label, provide an empty string.
+        y_label:
+            The label for the y-axis. Default is "Machines". To remove the
+            label, provide an empty string.
+
+    Returns:
+        - A ``matplotlib.figure.Figure`` object.
+        - A ``matplotlib.axes.Axes`` object where the Gantt chart is plotted.
     """
-    fig, ax = _initialize_plot(schedule, title)
-    legend_handles = _plot_machine_schedules(schedule, ax, cmap_name)
-    _configure_legend(ax, legend_handles)
-    _configure_axes(schedule, ax, xlim, number_of_x_ticks)
+    fig, ax = _initialize_plot(schedule, title, x_label, y_label)
+    legend_handles = _plot_machine_schedules(
+        schedule, ax, cmap_name, job_labels
+    )
+    _configure_legend(ax, legend_handles, legend_title)
+    _configure_axes(schedule, ax, xlim, number_of_x_ticks, machine_labels)
     return fig, ax
 
 
 def _initialize_plot(
-    schedule: Schedule, title: str | None
+    schedule: Schedule,
+    title: str | None,
+    x_label: str = "Time units",
+    y_label: str = "Machines",
 ) -> tuple[Figure, plt.Axes]:
     """Initializes the plot."""
     fig, ax = plt.subplots()
-    ax.set_xlabel("Time units")
-    ax.set_ylabel("Machines")
+    ax.set_xlabel(x_label)
+    ax.set_ylabel(y_label)
     ax.grid(True, which="both", axis="x", linestyle="--", linewidth=0.5)
     ax.yaxis.grid(False)
     if title is None:
@@ -61,7 +108,10 @@ def _initialize_plot(
 
 
 def _plot_machine_schedules(
-    schedule: Schedule, ax: plt.Axes, cmap_name: str
+    schedule: Schedule,
+    ax: plt.Axes,
+    cmap_name: str,
+    job_labels: list[str] | None,
 ) -> dict[int, Patch]:
     """Plots the schedules for each machine."""
     max_job_id = schedule.instance.num_jobs - 1
@@ -81,12 +131,20 @@ def _plot_machine_schedules(
             )
             if scheduled_op.job_id not in legend_handles:
                 legend_handles[scheduled_op.job_id] = Patch(
-                    facecolor=color, label=f"Job {scheduled_op.job_id}"
+                    facecolor=color,
+                    label=_get_job_label(job_labels, scheduled_op.job_id),
                 )
 
     return legend_handles
 
 
+def _get_job_label(job_labels: list[str] | None, job_id: int) -> str:
+    """Returns the label for the job."""
+    if job_labels is None:
+        return f"Job {job_id}"
+    return job_labels[job_id]
+
+
 def _plot_scheduled_operation(
     ax: plt.Axes,
     scheduled_op: ScheduledOperation,
@@ -103,7 +161,9 @@ def _plot_scheduled_operation(
     )
 
 
-def _configure_legend(ax: plt.Axes, legend_handles: dict[int, Patch]):
+def _configure_legend(
+    ax: plt.Axes, legend_handles: dict[int, Patch], legend_title: str
+):
     """Configures the legend for the plot."""
     sorted_legend_handles = [
         legend_handles[job_id] for job_id in sorted(legend_handles)
@@ -111,7 +171,8 @@ def _configure_legend(ax: plt.Axes, legend_handles: dict[int, Patch]):
     ax.legend(
         handles=sorted_legend_handles,
         loc="upper left",
-        bbox_to_anchor=(1.01, 1),
+        bbox_to_anchor=(1, 1),
+        title=legend_title,
     )
 
 
@@ -120,6 +181,7 @@ def _configure_axes(
     ax: plt.Axes,
     xlim: Optional[int],
     number_of_x_ticks: int,
+    machine_labels: list[str] | None,
 ):
     """Sets the limits and labels for the axes."""
     num_machines = len(schedule.schedule)
@@ -132,7 +194,9 @@ def _configure_axes(
             for i in range(num_machines)
         ]
     )
-    ax.set_yticklabels([str(i) for i in range(num_machines)])
+    if machine_labels is None:
+        machine_labels = [str(i) for i in range(num_machines)]
+    ax.set_yticklabels(machine_labels)
     makespan = schedule.makespan()
     xlim = xlim if xlim is not None else makespan
     ax.set_xlim(0, xlim)

{job_shop_lib-1.0.0a2.dist-info → job_shop_lib-1.0.0a3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: job-shop-lib
-Version: 1.0.0a2
+Version: 1.0.0a3
 Summary: An easy-to-use and modular Python library for the Job Shop Scheduling Problem (JSSP)
 License: MIT
 Author: Pabloo22
@@ -29,6 +29,7 @@ Description-Content-Type: text/markdown
 <h1>JobShopLib</h1>
 
 [![Tests](https://github.com/Pabloo22/job_shop_lib/actions/workflows/tests.yaml/badge.svg)](https://github.com/Pabloo22/job_shop_lib/actions/workflows/tests.yaml)
+[![Documentation Status](https://readthedocs.org/projects/job-shop-lib/badge/?version=latest)](https://job-shop-lib.readthedocs.io/en/latest/?badge=latest)
 ![Python versions](https://img.shields.io/badge/python-3.10%20%7C%203.11%20%7C%203.12-blue)
 [![Black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
@@ -39,7 +40,7 @@ JobShopLib is a Python package for creating, solving, and visualizing Job Shop S
 
 It follows a modular design, allowing users to easily extend the library with new solvers, dispatching rules, visualization functions, etc.
 
-See [this](https://colab.research.google.com/drive/1XV_Rvq1F2ns6DFG8uNj66q_rcowwTZ4H?usp=sharing) Google Colab notebook for a quick start guide! 
+See the [documentation](https://job-shop-lib.readthedocs.io/en/latest/) for more details about the latest version (1.0.0a2).
 
 ## Installation :package:
 
@@ -47,12 +48,23 @@ See [this](https://colab.research.google.com/drive/1XV_Rvq1F2ns6DFG8uNj66q_rcoww
 
 JobShopLib is distributed on [PyPI](https://pypi.org/project/job-shop-lib/) and it supports Python 3.10+.
 
-You can install the latest version using `pip`:
+You can install the latest stable version (version 0.5.1) using `pip`:
 
 ```bash
 pip install job-shop-lib
 ```
 
+See [this](https://colab.research.google.com/drive/1XV_Rvq1F2ns6DFG8uNj66q_rcowwTZ4H?usp=sharing) Google Colab notebook for a quick start guide! 
+
+
+Version 1.0.0 is currently in beta stage and can be installed with:
+
+```bash
+pip install job-shop-lib==1.0.0a3
+```
+
+Although this version is not stable and may contain breaking changes in subsequent releases, it is recommended to install it to access the new reinforcement learning environments and familiare yourself with new changes (see the [latest pull requests](https://github.com/Pabloo22/job_shop_lib/pulls?q=is%3Apr+is%3Aclosed)). This version is the first one with a [documentation page](https://job-shop-lib.readthedocs.io/en/latest/).
+
 <!-- end installation -->
 
 <!-- key features -->

{job_shop_lib-1.0.0a2.dist-info → job_shop_lib-1.0.0a3.dist-info}/RECORD

@@ -1,20 +1,20 @@
 job_shop_lib/__init__.py,sha256=Ci5ipn-zciO88C5aX5Wx-UN8iBTbpde3dSSg02ZcfwM,597
 job_shop_lib/_base_solver.py,sha256=p17XmtufNc9Y481cqZUT45pEkUmmW1HWG53dfhIBJH8,1363
-job_shop_lib/_job_shop_instance.py,sha256=Q0ml3C36tmcBskBo8MyaZWILJPbdvHjJcvXzD_YfLsU,16475
-job_shop_lib/_operation.py,sha256=lJ4srQs82cYhUYuBxqkfKr9MuZoG0X2x0z3M1_QXkAs,3360
-job_shop_lib/_schedule.py,sha256=H6PREUE9KCC0DtrQV8y9MB8S4sh3qnDwby5Y4WVDfzg,11333
-job_shop_lib/_scheduled_operation.py,sha256=ptqYRW39EvG5tnk4DLQGFCOkbGTTYIQJhUMcuLSbdSA,2812
+job_shop_lib/_job_shop_instance.py,sha256=Ubmm10DWO9SmhCOFsvEqeww7XFn-60JWTPDA40FOWZE,16434
+job_shop_lib/_operation.py,sha256=wAYijQtKPPPuXQo9648tYV1GFUU9XGiXIRQgPsCbYtM,3404
+job_shop_lib/_schedule.py,sha256=McDpisMyygxhw349Hxe4N3mCnugr8B5dVNCGN6sSYKg,11371
+job_shop_lib/_scheduled_operation.py,sha256=a1LW2LQvpH1WTxpE2x792_glp5M_gInCf70fuBiheqc,2828
 job_shop_lib/benchmarking/__init__.py,sha256=BYCrJUNr_uk2c0xIbDt07OnUMhQx8Dudkukx3TFWxgw,3271
 job_shop_lib/benchmarking/_load_benchmark.py,sha256=-cgyx0Kn6uAc3KdGFSQb6eUVQjQggmpVKOH9qusNkXI,2930
 job_shop_lib/benchmarking/benchmark_instances.json,sha256=F9EvyzFwVxiKAN6rQTsrMhsKstmyUmroyWduM7a00KQ,464841
 job_shop_lib/constraint_programming/__init__.py,sha256=kKQRUxxS_nVFUdXGnf4bQOD9mqrXxZZWElS753A4YiA,454
 job_shop_lib/constraint_programming/_ortools_solver.py,sha256=gRoImEBUa8_io-TzbSS-3f0CJ7UwacU5Lrz0bsDqibo,10462
-job_shop_lib/dispatching/__init__.py,sha256=QV7qy-y0sSoKp_FslTm7sdqczYzpq0YctzKQ36l0ykg,1510
-job_shop_lib/dispatching/_dispatcher.py,sha256=PCSBpYAF6QPXWrjwkBQXTxOdGdq6Y1Uqw8esQTW05TQ,21357
+job_shop_lib/dispatching/__init__.py,sha256=2VQYWNSyuDx3zzrDPCEzs5VJd2AIJvF7vA7LwK5z2V4,1648
+job_shop_lib/dispatching/_dispatcher.py,sha256=o0BqZBub9flPAHX59qBHV2RETQg7n31xHe6owg9Ki7U,21305
 job_shop_lib/dispatching/_dispatcher_observer_config.py,sha256=l_lbaw9JJ5icVOmDAzAL6G5t6wG25bQLpRedN1bys8c,1932
-job_shop_lib/dispatching/_factories.py,sha256=UAZLq7d_-puzMYteiAbbhkcW5ucKO-lo3bj8pCCEnOA,4229
+job_shop_lib/dispatching/_factories.py,sha256=MYnjuK9NOVU9n98mrNu5Z0svBIYBCTDbVGzUX9rDWsQ,4594
 job_shop_lib/dispatching/_history_observer.py,sha256=Vl8rQaxekUeEB-AyNxyC3c76zQakeh-rdri2iDnZvXw,610
-job_shop_lib/dispatching/_ready_operation_filters.py,sha256=q8Xv4kp_2GsvEMC5mlTuJXivAz_b8bbrqo5sXaS3PJU,3110
+job_shop_lib/dispatching/_ready_operation_filters.py,sha256=Mywt57h8Nlj6XrptWakVt9n1Tq4jsneZFQEgjLMxJgw,5731
 job_shop_lib/dispatching/_unscheduled_operations_observer.py,sha256=LNEzqOWqEf6fvtkQrDmDWFEhCfA75OgEtzdomzbxYII,2683
 job_shop_lib/dispatching/feature_observers/__init__.py,sha256=EuJLvSpJpoXUK8A4UuC2k6Mpa293ZR3oCnnvYivIBtU,2240
 job_shop_lib/dispatching/feature_observers/_composite_feature_observer.py,sha256=DOS961MtWaDk2gxjOLA_75SyT6Nmn3IKuNtYO8odk8s,7938
@@ -23,14 +23,14 @@ job_shop_lib/dispatching/feature_observers/_earliest_start_time_observer.py,sha2
 job_shop_lib/dispatching/feature_observers/_factory.py,sha256=b5YyzdnorijtWUNrYWs4sf-G17eDxw8oYrol1rzMN1Q,2919
 job_shop_lib/dispatching/feature_observers/_feature_observer.py,sha256=crbqG1KrmUOfG4z7shHNzhUg7-uSP4_RWxyOi-RRWmE,8635
 job_shop_lib/dispatching/feature_observers/_is_completed_observer.py,sha256=wKmlASLjodztAB2ypTsi0XFLZ3h1ltzvsa9BpPrbksU,4581
-job_shop_lib/dispatching/feature_observers/_is_ready_observer.py,sha256=KYDUO3Zz1wgkClZ64i5-az6W-SFpi8rckAlv4Zjcii4,1260
+job_shop_lib/dispatching/feature_observers/_is_ready_observer.py,sha256=wy_pA-1wmnzVjhq92mdsT2JJHYbfsm79mcMgSgYUCOs,1264
 job_shop_lib/dispatching/feature_observers/_is_scheduled_observer.py,sha256=OcuMUB9_By6ZMtX-1_3z-xaxGbP85a5Zv0ywAv7XxWQ,1491
 job_shop_lib/dispatching/feature_observers/_position_in_job_observer.py,sha256=WRknpQBKXs6h6cXLFJW7ZCvjtU8CPL-iXXNPw3g-mLE,1303
 job_shop_lib/dispatching/feature_observers/_remaining_operations_observer.py,sha256=5V87lCrJUabEe8AkTGXPu5yS8OGxeN8L3-xNyHmdmLs,1441
 job_shop_lib/dispatching/rules/__init__.py,sha256=p1rkqf66L62uvAOM1ZxNV8xHoh7SuYjHi_8ZNBvPIjg,1450
 job_shop_lib/dispatching/rules/_dispatching_rule_factory.py,sha256=5fNpv90fAoR6rcE6NeJOWiB7ir-FVnoONIhHtKJ9H0E,2904
-job_shop_lib/dispatching/rules/_dispatching_rule_solver.py,sha256=Nb3EPSIdnbeqKaIf5ufE2zxQsNpNkZxmYa0Eh1jnCnw,5537
-job_shop_lib/dispatching/rules/_dispatching_rules_functions.py,sha256=Wb9fQIfePvCJi4RqJ59UrRSnYufgQw5nQ_Am8M6-JOI,7569
+job_shop_lib/dispatching/rules/_dispatching_rule_solver.py,sha256=YgcxDUx9RqwfTxWtoKesngYVFDsHiWtsm1BAUrAyerY,6353
+job_shop_lib/dispatching/rules/_dispatching_rules_functions.py,sha256=yRJXYH6QSxDCIK8vqNUfMCMpzWmr3j_camAR72Z6D9Q,7605
 job_shop_lib/dispatching/rules/_machine_chooser_factory.py,sha256=xsJ8nJwPDBi-sfLJRQF_BBQDbyXDfopD1U-efXffQAE,2331
 job_shop_lib/dispatching/rules/_utils.py,sha256=X8vET2p1D3RyoB9mFfsfRgmilcTmxPssKYyJQ2zEt0Q,4605
 job_shop_lib/exceptions.py,sha256=ARzpoZJCvRIvOesCiqqFSRxkv6w9WwEXx0aBP-l2IKA,1597
@@ -51,16 +51,16 @@ job_shop_lib/graphs/graph_updaters/_utils.py,sha256=X5YfwJA1CCgpm1r9C036Gal2CkDh
 job_shop_lib/reinforcement_learning/__init__.py,sha256=QVFo9e1X-tpanZkGdcCPV_WobQ2EZ_y5uoYSJ36XrQI,957
 job_shop_lib/reinforcement_learning/_multi_job_shop_graph_env.py,sha256=jKMcWYBvz1kwlw00Xe1x9HqhFkMMqlh-Y95NmeBL3-0,15129
 job_shop_lib/reinforcement_learning/_reward_observers.py,sha256=4Kdyn9Jlp_1sBtVr6raF-ZFtcnKxwyCLykfX53TmuhU,2959
-job_shop_lib/reinforcement_learning/_single_job_shop_graph_env.py,sha256=Kbd3N1rKcXm6IHTo99En-oX85vqVobv2bFBCyAht2mE,12949
+job_shop_lib/reinforcement_learning/_single_job_shop_graph_env.py,sha256=ByQQ1fCCpji0VAjKTcbBOGST-3MF6oq2naAtdElJUh8,12953
 job_shop_lib/reinforcement_learning/_types_and_constants.py,sha256=CY849lbv6UXy40KRcMJT3WxvGWrLqcfysu65LPkTfg8,1715
 job_shop_lib/reinforcement_learning/_utils.py,sha256=ilI089Bs8CRlfRV_yH6XH8oypTDtRa7hS-H4iRCC5lU,2497
-job_shop_lib/visualization/__init__.py,sha256=jXC188u5AnSWcO1lRZEzZAPZTXbqlYSPhYc7LMc0itU,1094
+job_shop_lib/visualization/__init__.py,sha256=SVxg7Dt3azETfI0IvUtLtCBsirXQWirdjEjOQ2d5eWU,1137
 job_shop_lib/visualization/_agent_task_graph.py,sha256=AaBTD_S34WjrsZnL_iMAplR_f67RahZi7x58SOvp-q0,8834
 job_shop_lib/visualization/_disjunctive_graph.py,sha256=pg4KG9BfQbnBPnXYgbyPGe0AuHSmhYqPeqWYAf_spWQ,5905
-job_shop_lib/visualization/_gantt_chart.py,sha256=B9sn4XrEUqgQhRKju-1VUG5R67AZXRu7jbrtA8VcndU,4412
-job_shop_lib/visualization/_gantt_chart_creator.py,sha256=qFhCfk3oC3uF7Mau3lrNhH-34sfHXvkqEXbsDzrIbBk,7721
-job_shop_lib/visualization/_gantt_chart_video_and_gif_creation.py,sha256=GQhQF2YzSRQT_DdUjJYHFKMZMjk_hPrYjQU5PpedNvs,13213
-job_shop_lib-1.0.0a2.dist-info/LICENSE,sha256=9mggivMGd5taAu3xbmBway-VQZMBzurBGHofFopvUsQ,1069
-job_shop_lib-1.0.0a2.dist-info/METADATA,sha256=IVDNFeNtFCpjUzIGXkEn0uQ3aBgJLSLXHuJKEgpBajI,14810
-job_shop_lib-1.0.0a2.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-job_shop_lib-1.0.0a2.dist-info/RECORD,,
+job_shop_lib/visualization/_gantt_chart_creator.py,sha256=xw7lfd1HIm7r5j2kDxgBdrgSickCslpUcm7QFrNXmtg,7763
+job_shop_lib/visualization/_gantt_chart_video_and_gif_creation.py,sha256=IpKe2oZbrW4fvsdnRtuFWfXN-FdfwkYVdTAq3av9mKE,14249
+job_shop_lib/visualization/_plot_gantt_chart.py,sha256=1WCJ5Gjl3dwA-w4Jn9suIg-ZGR28yYUAy8Jp-IiyvfI,6842
+job_shop_lib-1.0.0a3.dist-info/LICENSE,sha256=9mggivMGd5taAu3xbmBway-VQZMBzurBGHofFopvUsQ,1069
+job_shop_lib-1.0.0a3.dist-info/METADATA,sha256=fJ7RYm8yUkmZvG5moRO5QUVDw0_ACIcqb7gxiuqLrQo,15663
+job_shop_lib-1.0.0a3.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+job_shop_lib-1.0.0a3.dist-info/RECORD,,

{job_shop_lib-1.0.0a2.dist-info → job_shop_lib-1.0.0a3.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.8.1
+Generator: poetry-core 1.9.0
 Root-Is-Purelib: true
 Tag: py3-none-any