job-shop-lib 1.0.2__py3-none-any.whl → 1.0.3__py3-none-any.whl

job_shop_lib/reinforcement_learning/_single_job_shop_graph_env.py

@@ -2,7 +2,7 @@
 
 from copy import deepcopy
 from collections.abc import Callable, Sequence
-from typing import Any, Dict, Tuple, List, Optional, Type, Union
+from typing import Any
 
 import matplotlib.pyplot as plt
 import gymnasium as gym
@@ -140,24 +140,22 @@ class SingleJobShopGraphEnv(gym.Env):
         self,
         job_shop_graph: JobShopGraph,
         feature_observer_configs: Sequence[
-            Union[
-                str,
-                FeatureObserverType,
-                Type[FeatureObserver],
-                FeatureObserverConfig,
-            ],
+            str
+            | FeatureObserverType
+            | type[FeatureObserver]
+            | FeatureObserverConfig
         ],
         reward_function_config: DispatcherObserverConfig[
-            Type[RewardObserver]
+            type[RewardObserver]
         ] = DispatcherObserverConfig(class_type=MakespanReward),
         graph_updater_config: DispatcherObserverConfig[
-            Type[GraphUpdater]
+            type[GraphUpdater]
         ] = DispatcherObserverConfig(class_type=ResidualGraphUpdater),
-        ready_operations_filter: Optional[
-            Callable[[Dispatcher, List[Operation]], List[Operation]]
-        ] = filter_dominated_operations,
-        render_mode: Optional[str] = None,
-        render_config: Optional[RenderConfig] = None,
+        ready_operations_filter: (
+            Callable[[Dispatcher, list[Operation]], list[Operation]] | None
+        ) = filter_dominated_operations,
+        render_mode: str | None = None,
+        render_config: RenderConfig | None = None,
         use_padding: bool = True,
     ) -> None:
         super().__init__()
@@ -224,7 +222,7 @@ class SingleJobShopGraphEnv(gym.Env):
     def _get_observation_space(self) -> gym.spaces.Dict:
         """Returns the observation space dictionary."""
         num_edges = self.job_shop_graph.num_edges
-        dict_space: Dict[str, gym.Space] = {
+        dict_space: dict[str, gym.Space] = {
             ObservationSpaceKey.REMOVED_NODES.value: gym.spaces.MultiBinary(
                 len(self.job_shop_graph.nodes)
             ),
@@ -250,9 +248,9 @@ class SingleJobShopGraphEnv(gym.Env):
     def reset(
         self,
         *,
-        seed: Optional[int] = None,
-        options: Optional[Dict[str, Any]] = None,
-    ) -> Tuple[ObservationDict, dict[str, Any]]:
+        seed: int | None = None,
+        options: dict[str, Any] | None = None,
+    ) -> tuple[ObservationDict, dict[str, Any]]:
         """Resets the environment.
 
         Args:
@@ -284,8 +282,8 @@ class SingleJobShopGraphEnv(gym.Env):
         }
 
     def step(
-        self, action: Tuple[int, int]
-    ) -> Tuple[ObservationDict, float, bool, bool, Dict[str, Any]]:
+        self, action: tuple[int, int]
+    ) -> tuple[ObservationDict, float, bool, bool, dict[str, Any]]:
         """Takes a step in the environment.
 
         Args:
@@ -319,7 +317,7 @@ class SingleJobShopGraphEnv(gym.Env):
         reward = self.reward_function.last_reward
         done = self.dispatcher.schedule.is_complete()
         truncated = False
-        info: Dict[str, Any] = {
+        info: dict[str, Any] = {
             "feature_names": self.composite_observer.column_names,
             "available_operations_with_ids": (
                 self.get_available_actions_with_ids()
@@ -374,7 +372,7 @@ class SingleJobShopGraphEnv(gym.Env):
         elif self.render_mode == "save_gif":
             self.gantt_chart_creator.create_gif()
 
-    def get_available_actions_with_ids(self) -> List[Tuple[int, int, int]]:
+    def get_available_actions_with_ids(self) -> list[tuple[int, int, int]]:
         """Returns a list of available actions in the form of
         (operation_id, machine_id, job_id)."""
         available_operations = self.dispatcher.available_operations()
@@ -388,7 +386,7 @@ class SingleJobShopGraphEnv(gym.Env):
                 )
         return available_operations_with_ids
 
-    def validate_action(self, action: Tuple[int, int]) -> None:
+    def validate_action(self, action: tuple[int, int]) -> None:
         """Validates that the action is legal in the current state.
 
         Args:
@@ -428,7 +426,7 @@ if __name__ == "__main__":
 
     instance = load_benchmark_instance("ft06")
     job_shop_graph_ = build_disjunctive_graph(instance)
-    feature_observer_configs_: List[DispatcherObserverConfig] = [
+    feature_observer_configs_: list[DispatcherObserverConfig] = [
         DispatcherObserverConfig(
             FeatureObserverType.IS_READY,
             kwargs={"feature_types": [FeatureType.JOBS]},

job_shop_lib/reinforcement_learning/_utils.py

@@ -1,6 +1,6 @@
 """Utility functions for reinforcement learning."""
 
-from typing import TypeVar, Any, Type
+from typing import TypeVar, Any
 
 import numpy as np
 from numpy.typing import NDArray
@@ -15,7 +15,7 @@ def add_padding(
     array: NDArray[Any],
     output_shape: tuple[int, ...],
     padding_value: float = -1,
-    dtype: Type[T] | None = None,
+    dtype: type[T] | None = None,
 ) -> NDArray[T]:
     """Adds padding to the array.
 

job_shop_lib/visualization/gantt/_gantt_chart_creator.py

@@ -1,6 +1,6 @@
 """Home of the `GanttChartCreator` class and its configuration types."""
 
-from typing import TypedDict, Optional
+from typing import TypedDict
 import matplotlib.pyplot as plt
 
 from job_shop_lib.dispatching import (
@@ -24,7 +24,7 @@ class PartialGanttChartPlotterConfig(TypedDict, total=False):
         - :func:`get_partial_gantt_chart_plotter`
     """
 
-    title: Optional[str]
+    title: str | None
     """The title of the Gantt chart."""
 
     cmap: str
@@ -43,7 +43,7 @@ class GifConfig(TypedDict, total=False):
         :func:`create_gantt_chart_gif`
     """
 
-    gif_path: Optional[str]
+    gif_path: str | None
     """The path to save the GIF. It must end with '.gif'."""
 
     fps: int
@@ -52,7 +52,7 @@ class GifConfig(TypedDict, total=False):
     remove_frames: bool
     """Whether to remove the frames after creating the GIF."""
 
-    frames_dir: Optional[str]
+    frames_dir: str | None
     """The directory to store the frames."""
 
     plot_current_time: bool
@@ -68,7 +68,7 @@ class VideoConfig(TypedDict, total=False):
         :func:`create_gantt_chart_video`
     """
 
-    video_path: Optional[str]
+    video_path: str | None
     """The path to save the video. It must end with a valid video extension
     (e.g., '.mp4')."""
 
@@ -78,7 +78,7 @@ class VideoConfig(TypedDict, total=False):
     remove_frames: bool
     """Whether to remove the frames after creating the video."""
 
-    frames_dir: Optional[str]
+    frames_dir: str | None
     """The directory to store the frames."""
 
     plot_current_time: bool
@@ -164,11 +164,11 @@ class GanttChartCreator:
     def __init__(
         self,
         dispatcher: Dispatcher,
-        partial_gantt_chart_plotter_config: Optional[
-            PartialGanttChartPlotterConfig
-        ] = None,
-        gif_config: Optional[GifConfig] = None,
-        video_config: Optional[VideoConfig] = None,
+        partial_gantt_chart_plotter_config: (
+            PartialGanttChartPlotterConfig | None
+        ) = None,
+        gif_config: GifConfig | None = None,
+        video_config: VideoConfig | None = None,
     ):
         if gif_config is None:
             gif_config = {}

job_shop_lib/visualization/gantt/_gantt_chart_video_and_gif_creation.py

@@ -3,7 +3,7 @@
 import os
 import pathlib
 import shutil
-from typing import Sequence, Protocol, Optional, List, Any
+from typing import Sequence, Protocol, Any
 
 import imageio
 import matplotlib.pyplot as plt
@@ -43,9 +43,9 @@ class PartialGanttChartPlotter(Protocol):
     def __call__(
         self,
         schedule: Schedule,
-        makespan: Optional[int] = None,
-        available_operations: Optional[List[Operation]] = None,
-        current_time: Optional[int] = None,
+        makespan: int | None = None,
+        available_operations: list[Operation] | None = None,
+        current_time: int | None = None,
     ) -> Figure:
         """Plots a Gantt chart for an unfinished schedule.
 
@@ -65,7 +65,7 @@ class PartialGanttChartPlotter(Protocol):
 
 
 def get_partial_gantt_chart_plotter(
-    title: Optional[str] = None,
+    title: str | None = None,
     cmap: str = "viridis",
     show_available_operations: bool = False,
     **kwargs: Any,
@@ -95,9 +95,9 @@ def get_partial_gantt_chart_plotter(
 
     def plot_function(
         schedule: Schedule,
-        makespan: Optional[int] = None,
-        available_operations: Optional[List[Operation]] = None,
-        current_time: Optional[int] = None,
+        makespan: int | None = None,
+        available_operations: list[Operation] | None = None,
+        current_time: int | None = None,
     ) -> Figure:
         fig, ax = plot_gantt_chart(
             schedule, title=title, cmap_name=cmap, xlim=makespan, **kwargs
@@ -136,14 +136,14 @@ def get_partial_gantt_chart_plotter(
 # pylint: disable=too-many-arguments
 def create_gantt_chart_gif(
     instance: JobShopInstance,
-    gif_path: Optional[str] = None,
-    solver: Optional[DispatchingRuleSolver] = None,
-    plot_function: Optional[PartialGanttChartPlotter] = None,
+    gif_path: str | None = None,
+    solver: DispatchingRuleSolver | None = None,
+    plot_function: PartialGanttChartPlotter | None = None,
     fps: int = 1,
     remove_frames: bool = True,
-    frames_dir: Optional[str] = None,
+    frames_dir: str | None = None,
     plot_current_time: bool = True,
-    schedule_history: Optional[Sequence[ScheduledOperation]] = None,
+    schedule_history: Sequence[ScheduledOperation] | None = None,
 ) -> None:
     """Creates a GIF of the schedule being built.
 
@@ -205,14 +205,14 @@ def create_gantt_chart_gif(
 # pylint: disable=too-many-arguments
 def create_gantt_chart_video(
     instance: JobShopInstance,
-    video_path: Optional[str] = None,
-    solver: Optional[DispatchingRuleSolver] = None,
-    plot_function: Optional[PartialGanttChartPlotter] = None,
+    video_path: str | None = None,
+    solver: DispatchingRuleSolver | None = None,
+    plot_function: PartialGanttChartPlotter | None = None,
     fps: int = 1,
     remove_frames: bool = True,
-    frames_dir: Optional[str] = None,
+    frames_dir: str | None = None,
     plot_current_time: bool = True,
-    schedule_history: Optional[Sequence[ScheduledOperation]] = None,
+    schedule_history: Sequence[ScheduledOperation] | None = None,
 ) -> None:
     """Creates a video of the schedule being built.
 
@@ -271,10 +271,10 @@ def create_gantt_chart_video(
 def create_gantt_chart_frames(
     frames_dir: str,
     instance: JobShopInstance,
-    solver: Optional[DispatchingRuleSolver],
+    solver: DispatchingRuleSolver | None,
     plot_function: PartialGanttChartPlotter,
     plot_current_time: bool = True,
-    schedule_history: Optional[Sequence[ScheduledOperation]] = None,
+    schedule_history: Sequence[ScheduledOperation] | None = None,
 ) -> None:
     """Creates frames of the Gantt chart for the schedule being built.
 
@@ -414,7 +414,7 @@ def resize_image_to_macro_block(
     return image
 
 
-def _load_images(frames_dir: str) -> List:
+def _load_images(frames_dir: str) -> list:
     frames = [
         os.path.join(frames_dir, frame)
         for frame in sorted(os.listdir(frames_dir))

job_shop_lib/visualization/gantt/_plot_gantt_chart.py

@@ -1,7 +1,5 @@
 """Module for plotting static Gantt charts for job shop schedules."""
 
-from typing import Optional, List, Tuple, Dict
-
 from matplotlib.figure import Figure
 import matplotlib.pyplot as plt
 from matplotlib.colors import Normalize
@@ -15,16 +13,16 @@ _Y_POSITION_INCREMENT = 10
 
 def plot_gantt_chart(
     schedule: Schedule,
-    title: Optional[str] = None,
+    title: str | None = None,
     cmap_name: str = "viridis",
-    xlim: Optional[int] = None,
+    xlim: int | None = None,
     number_of_x_ticks: int = 15,
-    job_labels: Optional[List[str]] = None,
-    machine_labels: Optional[List[str]] = None,
+    job_labels: list[str] | None = None,
+    machine_labels: list[str] | None = None,
     legend_title: str = "",
     x_label: str = "Time units",
     y_label: str = "Machines",
-) -> Tuple[Figure, plt.Axes]:
+) -> tuple[Figure, plt.Axes]:
     """Plots a Gantt chart for the schedule.
 
     This function generates a Gantt chart that visualizes the schedule of jobs
@@ -90,10 +88,10 @@ def plot_gantt_chart(
 
 def _initialize_plot(
     schedule: Schedule,
-    title: Optional[str],
+    title: str | None,
     x_label: str = "Time units",
     y_label: str = "Machines",
-) -> Tuple[Figure, plt.Axes]:
+) -> tuple[Figure, plt.Axes]:
     """Initializes the plot."""
     fig, ax = plt.subplots()
     ax.set_xlabel(x_label)
@@ -110,8 +108,8 @@ def _plot_machine_schedules(
     schedule: Schedule,
     ax: plt.Axes,
     cmap_name: str,
-    job_labels: Optional[List[str]],
-) -> Dict[int, Patch]:
+    job_labels: list[str] | None,
+) -> dict[int, Patch]:
     """Plots the schedules for each machine."""
     max_job_id = schedule.instance.num_jobs - 1
     cmap = plt.get_cmap(cmap_name, max_job_id + 1)
@@ -137,7 +135,7 @@ def _plot_machine_schedules(
     return legend_handles
 
 
-def _get_job_label(job_labels: Optional[List[str]], job_id: int) -> str:
+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}"
@@ -161,7 +159,7 @@ def _plot_scheduled_operation(
 
 
 def _configure_legend(
-    ax: plt.Axes, legend_handles: Dict[int, Patch], legend_title: str
+    ax: plt.Axes, legend_handles: dict[int, Patch], legend_title: str
 ):
     """Configures the legend for the plot."""
     sorted_legend_handles = [
@@ -178,7 +176,7 @@ def _configure_legend(
 def _configure_axes(
     schedule: Schedule,
     ax: plt.Axes,
-    xlim: Optional[int],
+    xlim: int | None,
     number_of_x_ticks: int,
     machine_labels: list[str] | None,
 ):

job_shop_lib/visualization/graphs/_plot_disjunctive_graph.py

@@ -1,7 +1,7 @@
 """Module for visualizing the disjunctive graph of a job shop instance."""
 
 import functools
-from typing import Any, Optional, Tuple, Dict, Union
+from typing import Any
 from collections.abc import Callable, Sequence, Iterable
 import warnings
 import copy
@@ -23,7 +23,7 @@ from job_shop_lib.graphs import (
 from job_shop_lib.exceptions import ValidationError
 
 
-Layout = Callable[[nx.Graph], Dict[str, Tuple[float, float]]]
+Layout = Callable[[nx.Graph], dict[str, tuple[float, float]]]
 
 
 def duration_labeler(node: Node) -> str:
@@ -56,10 +56,10 @@ def duration_labeler(node: Node) -> str:
 # pylint: disable=too-many-arguments, too-many-locals, too-many-statements
 # pylint: disable=too-many-branches, line-too-long
 def plot_disjunctive_graph(
-    job_shop: Union[JobShopGraph, JobShopInstance],
+    job_shop: JobShopGraph | JobShopInstance,
     *,
-    title: Optional[str] = None,
-    figsize: Tuple[float, float] = (6, 4),
+    title: str | None = None,
+    figsize: tuple[float, float] = (6, 4),
     node_size: int = 1600,
     edge_width: int = 2,
     font_size: int = 10,
@@ -67,27 +67,25 @@ def plot_disjunctive_graph(
     alpha: float = 0.95,
     operation_node_labeler: Callable[[Node], str] = duration_labeler,
     node_font_color: str = "white",
-    machine_colors: Optional[
-        Dict[int, Tuple[float, float, float, float]]
-    ] = None,
+    machine_colors: dict[int, tuple[float, float, float, float]] | None = None,
     color_map: str = "Dark2_r",
     disjunctive_edge_color: str = "red",
     conjunctive_edge_color: str = "black",
-    layout: Optional[Layout] = None,
-    draw_disjunctive_edges: Union[bool, str] = True,
-    conjunctive_edges_additional_params: Optional[Dict[str, Any]] = None,
-    disjunctive_edges_additional_params: Optional[Dict[str, Any]] = None,
+    layout: Layout | None = None,
+    draw_disjunctive_edges: bool | str = True,
+    conjunctive_edges_additional_params: dict[str, Any] | None = None,
+    disjunctive_edges_additional_params: dict[str, Any] | None = None,
     conjunctive_patch_label: str = "Conjunctive edges",
     disjunctive_patch_label: str = "Disjunctive edges",
     legend_text: str = "$p_{ij}=$duration of $O_{ij}$",
     show_machine_colors_in_legend: bool = True,
-    machine_labels: Optional[Sequence[str]] = None,
+    machine_labels: Sequence[str] | None = None,
     legend_location: str = "upper left",
-    legend_bbox_to_anchor: Tuple[float, float] = (1.01, 1),
+    legend_bbox_to_anchor: tuple[float, float] = (1.01, 1),
     start_node_label: str = "$S$",
     end_node_label: str = "$T$",
     font_family: str = "sans-serif",
-) -> Tuple[plt.Figure, plt.Axes]:
+) -> tuple[plt.Figure, plt.Axes]:
     r"""Plots the disjunctive graph of the given job shop instance or graph.
 
     Args:
@@ -240,7 +238,7 @@ def plot_disjunctive_graph(
     # Draw nodes
     # ----------
     operation_nodes = job_shop_graph.nodes_by_type[NodeType.OPERATION]
-    cmap_func: Optional[matplotlib.colors.Colormap] = None
+    cmap_func: matplotlib.colors.Colormap | None = None
     if machine_colors is None:
         machine_colors = {}
         cmap_func = matplotlib.colormaps.get_cmap(color_map)
@@ -289,7 +287,7 @@ def plot_disjunctive_graph(
         for u, v, d in job_shop_graph.graph.edges(data=True)
         if d["type"] == EdgeType.CONJUNCTIVE
     ]
-    disjunctive_edges: Iterable[Tuple[int, int]] = [
+    disjunctive_edges: Iterable[tuple[int, int]] = [
         (u, v)
         for u, v, d in job_shop_graph.graph.edges(data=True)
         if d["type"] == EdgeType.DISJUNCTIVE

job_shop_lib/visualization/graphs/_plot_resource_task_graph.py

@@ -10,7 +10,7 @@ all operation nodes from the same job are connected by non-directed edges too.
 
 from collections.abc import Callable
 from copy import deepcopy
-from typing import Optional, Any, Tuple, Dict, Union, List
+from typing import Any
 
 import matplotlib.pyplot as plt
 import matplotlib.colors as mcolors
@@ -22,24 +22,22 @@ from job_shop_lib.graphs import NodeType, JobShopGraph, Node
 def plot_resource_task_graph(
     job_shop_graph: JobShopGraph,
     *,
-    title: Optional[str] = None,
-    figsize: Tuple[int, int] = (10, 10),
-    layout: Optional[Dict[Node, Tuple[float, float]]] = None,
+    title: str | None = None,
+    figsize: tuple[int, int] = (10, 10),
+    layout: dict[Node, tuple[float, float]] | None = None,
     node_size: int = 1200,
     node_font_color: str = "k",
     font_size: int = 10,
     alpha: float = 0.95,
     add_legend: bool = False,
-    node_shapes: Optional[Dict[str, str]] = None,
-    node_color_map: Optional[
-        Callable[[Node], Tuple[float, float, float, float]]
-    ] = None,
-    default_node_color: Union[
-        str, Tuple[float, float, float, float]
-    ] = "lightblue",
+    node_shapes: dict[str, str] | None = None,
+    node_color_map: (
+        Callable[[Node], tuple[float, float, float, float]] | None
+    ) = None,
+    default_node_color: str | tuple[float, float, float, float] = "lightblue",
     machine_color_map_name: str = "tab10",
     legend_text: str = "$p_{ij}$ = duration of $O_{ij}$",
-    edge_additional_params: Optional[Dict[str, Any]] = None,
+    edge_additional_params: dict[str, Any] | None = None,
     draw_only_one_edge: bool = False,
 ) -> plt.Figure:
     """Returns a plot of the hetereogeneous graph of the instance.
@@ -203,17 +201,17 @@ def _get_node_label(node: Node) -> str:
 
 
 def _color_to_rgba(
-    color: Union[str, Tuple[float, float, float, float]]
-) -> Tuple[float, float, float, float]:
+    color: str | tuple[float, float, float, float],
+) -> tuple[float, float, float, float]:
     if isinstance(color, str):
         return mcolors.to_rgba(color)
     return color
 
 
 def color_nodes_by_machine(
-    machine_colors: Dict[int, Tuple[float, float, float, float]],
-    default_color: Union[str, Tuple[float, float, float, float]],
-) -> Callable[[Node], Tuple[float, float, float, float]]:
+    machine_colors: dict[int, tuple[float, float, float, float]],
+    default_color: str | tuple[float, float, float, float],
+) -> Callable[[Node], tuple[float, float, float, float]]:
     """Returns a function that assigns a color to a node based on its type.
 
     The function returns a color based on the node type. If the node is an
@@ -234,7 +232,7 @@ def color_nodes_by_machine(
         values of the color to use in the plot.
     """
 
-    def _get_node_color(node: Node) -> Tuple[float, float, float, float]:
+    def _get_node_color(node: Node) -> tuple[float, float, float, float]:
         if node.node_type == NodeType.OPERATION:
             return machine_colors[node.operation.machine_id]
         if node.node_type == NodeType.MACHINE:
@@ -252,7 +250,7 @@ def three_columns_layout(
     rightmost_position: float = 0.9,
     topmost_position: float = 1.0,
     bottommost_position: float = 0.0,
-) -> Dict[Node, Tuple[float, float]]:
+) -> dict[Node, tuple[float, float]]:
     """Generates coordinates for a three-column grid layout.
 
     1. Left column: Machine nodes (M1, M2, etc.)
@@ -321,7 +319,7 @@ def three_columns_layout(
     total_positions = len(operation_nodes) + len(global_nodes) * 2
     y_spacing = (topmost_position - bottommost_position) / total_positions
 
-    layout: Dict[Node, Tuple[float, float]] = {}
+    layout: dict[Node, tuple[float, float]] = {}
 
     machines_spacing_multiplier = len(operation_nodes) // len(machine_nodes)
     layout.update(
@@ -364,7 +362,7 @@ def three_columns_layout(
 
 def _get_x_positions(
     leftmost_position: float, rightmost_position: float
-) -> Dict[str, float]:
+) -> dict[str, float]:
     center_position = (
         leftmost_position + (rightmost_position - leftmost_position) / 2
     )
@@ -376,12 +374,12 @@ def _get_x_positions(
 
 
 def _assign_positions_from_top(
-    nodes: List[Node],
+    nodes: list[Node],
     x: float,
     top: float,
     y_spacing: float,
-) -> Dict[Node, Tuple[float, float]]:
-    layout: Dict[Node, Tuple[float, float]] = {}
+) -> dict[Node, tuple[float, float]]:
+    layout: dict[Node, tuple[float, float]] = {}
     for i, node in enumerate(nodes):
         y = top - (i + 1) * y_spacing
         layout[node] = (x, y)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: job-shop-lib
-Version: 1.0.2
+Version: 1.0.3
 Summary: An easy-to-use and modular Python library for the Job Shop Scheduling Problem (JSSP)
 License: MIT
 Author: Pabloo22