job-shop-lib 1.0.0b4__py3-none-any.whl → 1.0.1__py3-none-any.whl

job_shop_lib/reinforcement_learning/__init__.py

@@ -13,6 +13,8 @@
     RenderConfig
     add_padding
     create_edge_type_dict
+    map_values
+    get_optimal_actions
     ResourceTaskGraphObservation
     ResourceTaskGraphObservationDict
 
@@ -34,6 +36,7 @@ from job_shop_lib.reinforcement_learning._utils import (
     add_padding,
     create_edge_type_dict,
     map_values,
+    get_optimal_actions,
 )
 
 from job_shop_lib.reinforcement_learning._single_job_shop_graph_env import (
@@ -61,4 +64,5 @@ __all__ = [
     "ResourceTaskGraphObservation",
     "map_values",
     "ResourceTaskGraphObservationDict",
+    "get_optimal_actions",
 ]

job_shop_lib/reinforcement_learning/_multi_job_shop_graph_env.py

@@ -117,7 +117,7 @@ class MultiJobShopGraphEnv(gym.Env):
         graph_initializer:
             Function to create the initial graph representation.
             If ``None``, the default graph initializer is used:
-            :func:`~job_shop_lib.graphs.build_agent_task_graph`.
+            :func:`~job_shop_lib.graphs.build_resource_task_graph`.
         graph_updater_config:
             Configuration for the graph updater. The graph updater is used
             to update the graph representation after each action. If

job_shop_lib/reinforcement_learning/_resource_task_graph_observation.py

@@ -1,6 +1,6 @@
 """Contains wrappers for the environments."""
 
-from typing import TypeVar, TypedDict
+from typing import TypeVar, TypedDict, Generic, Any
 from gymnasium import ObservationWrapper
 import numpy as np
 from numpy.typing import NDArray
@@ -12,23 +12,36 @@ from job_shop_lib.reinforcement_learning import (
     create_edge_type_dict,
     map_values,
 )
-from job_shop_lib.graphs import NodeType, JobShopGraph
-from job_shop_lib.exceptions import ValidationError
+from job_shop_lib.graphs import NodeType
 from job_shop_lib.dispatching.feature_observers import FeatureType
 
 T = TypeVar("T", bound=np.number)
+EnvType = TypeVar(  # pylint: disable=invalid-name
+    "EnvType", bound=SingleJobShopGraphEnv | MultiJobShopGraphEnv
+)
+
+_NODE_TYPE_TO_FEATURE_TYPE = {
+    NodeType.OPERATION: FeatureType.OPERATIONS,
+    NodeType.MACHINE: FeatureType.MACHINES,
+    NodeType.JOB: FeatureType.JOBS,
+}
+_FEATURE_TYPE_STR_TO_NODE_TYPE = {
+    FeatureType.OPERATIONS.value: NodeType.OPERATION,
+    FeatureType.MACHINES.value: NodeType.MACHINE,
+    FeatureType.JOBS.value: NodeType.JOB,
+}
 
 
 class ResourceTaskGraphObservationDict(TypedDict):
     """Represents a dictionary for resource task graph observations."""
 
-    edge_index_dict: dict[str, NDArray[np.int64]]
+    edge_index_dict: dict[tuple[str, str, str], NDArray[np.int32]]
     node_features_dict: dict[str, NDArray[np.float32]]
     original_ids_dict: dict[str, NDArray[np.int32]]
 
 
 # pylint: disable=line-too-long
-class ResourceTaskGraphObservation(ObservationWrapper):
+class ResourceTaskGraphObservation(ObservationWrapper, Generic[EnvType]):
     """Observation wrapper that converts an observation following the
     :class:`ObservationDict` format to a format suitable to PyG's
     [`HeteroData`](https://pytorch-geometric.readthedocs.io/en/latest/generated/torch_geometric.data.HeteroData.html).
@@ -38,6 +51,12 @@ class ResourceTaskGraphObservation(ObservationWrapper):
     ``node_type_j`` are the node types of the source and target nodes,
     respectively.
 
+    Additionally, the node features are stored in a dictionary with keys
+    corresponding to the node type names under the ``node_features_dict`` key.
+
+    The node IDs are mapped to local IDs starting from 0. The
+    ``original_ids_dict`` contains the original node IDs before removing nodes.
+
     Attributes:
         global_to_local_id: A dictionary mapping global node IDs to local node
             IDs for each node type.
@@ -48,25 +67,12 @@ class ResourceTaskGraphObservation(ObservationWrapper):
         env: The environment to wrap.
     """
 
-    def __init__(self, env: SingleJobShopGraphEnv | MultiJobShopGraphEnv):
+    def __init__(self, env: EnvType):
         super().__init__(env)
+        self.env = env  # Unnecessary, but makes mypy happy
         self.global_to_local_id = self._compute_id_mappings()
         self.type_ranges = self._compute_node_type_ranges()
-
-    @property
-    def job_shop_graph(self) -> JobShopGraph:
-        """Returns the job shop graph from the environment.
-
-        Raises:
-            ValidationError: If the environment is not an instance of
-                ``SingleJobShopGraphEnv`` or ``MultiJobShopGraphEnv``.
-        """
-        if isinstance(self.env, (SingleJobShopGraphEnv, MultiJobShopGraphEnv)):
-            return self.env.job_shop_graph
-        raise ValidationError(
-            "The environment must be an instance of "
-            "SingleJobShopGraphEnv or MultiJobShopGraphEnv"
-        )
+        self._start_from_zero_mapping: dict[str, dict[int, int]] = {}
 
     def step(self, action: tuple[int, int]):
         """Takes a step in the environment.
@@ -92,7 +98,9 @@ class ResourceTaskGraphObservation(ObservationWrapper):
               machine_id, job_id).
         """
         observation, reward, done, truncated, info = self.env.step(action)
-        return self.observation(observation), reward, done, truncated, info
+        new_observation = self.observation(observation)
+        new_info = self._info(info)
+        return new_observation, reward, done, truncated, new_info
 
     def reset(self, *, seed: int | None = None, options: dict | None = None):
         """Resets the environment.
@@ -116,7 +124,34 @@ class ResourceTaskGraphObservation(ObservationWrapper):
                 (operation_id, machine_id, job_id).
         """
         observation, info = self.env.reset()
-        return self.observation(observation), info
+        new_observation = self.observation(observation)
+        new_info = self._info(info)
+        return new_observation, new_info
+
+    def _info(self, info: dict[str, Any]) -> dict[str, Any]:
+        """Updates the "available_operations_with_ids" key in the info
+        dictionary so that they start from 0 using the
+        `_start_from_zero_mapping` attribute.
+        """
+        new_available_operations_ids = []
+        for operation_id, machine_id, job_id in info[
+            "available_operations_with_ids"
+        ]:
+            if "operation" in self._start_from_zero_mapping:
+                operation_id = self._start_from_zero_mapping["operation"][
+                    operation_id
+                ]
+            if "machine" in self._start_from_zero_mapping:
+                machine_id = self._start_from_zero_mapping["machine"][
+                    machine_id
+                ]
+            if "job" in self._start_from_zero_mapping:
+                job_id = self._start_from_zero_mapping["job"][job_id]
+            new_available_operations_ids.append(
+                (operation_id, machine_id, job_id)
+            )
+        info["available_operations_with_ids"] = new_available_operations_ids
+        return info
 
     def _compute_id_mappings(self) -> dict[int, int]:
         """Computes mappings from global node IDs to type-local IDs.
@@ -127,7 +162,7 @@ class ResourceTaskGraphObservation(ObservationWrapper):
         """
         mappings = {}
         for node_type in NodeType:
-            type_nodes = self.job_shop_graph.nodes_by_type[node_type]
+            type_nodes = self.unwrapped.job_shop_graph.nodes_by_type[node_type]
             if not type_nodes:
                 continue
             # Create mapping from global ID to local ID
@@ -148,7 +183,7 @@ class ResourceTaskGraphObservation(ObservationWrapper):
         """
         type_ranges = {}
         for node_type in NodeType:
-            type_nodes = self.job_shop_graph.nodes_by_type[node_type]
+            type_nodes = self.unwrapped.job_shop_graph.nodes_by_type[node_type]
             if not type_nodes:
                 continue
             start = min(node.node_id for node in type_nodes)
@@ -157,21 +192,50 @@ class ResourceTaskGraphObservation(ObservationWrapper):
 
         return type_ranges
 
-    def observation(self, observation: ObservationDict):
+    def observation(
+        self, observation: ObservationDict
+    ) -> ResourceTaskGraphObservationDict:
+        """Processes the observation data into the resource task graph format.
+
+        Args:
+            observation: The observation dictionary. It must NOT have padding.
+
+        Returns:
+            A dictionary containing the following keys:
+
+            - "edge_index_dict": A dictionary mapping edge types to edge index
+              arrays.
+            - "node_features_dict": A dictionary mapping node type names to
+                node feature arrays.
+            - "original_ids_dict": A dictionary mapping node type names to the
+              original node IDs before removing nodes.
+        """
         edge_index_dict = create_edge_type_dict(
             observation["edge_index"],
             type_ranges=self.type_ranges,
             relationship="to",
         )
+        node_features_dict = self._create_node_features_dict(observation)
+        node_features_dict, original_ids_dict = self._remove_nodes(
+            node_features_dict, observation["removed_nodes"]
+        )
+
         # mapping from global node ID to local node ID
         for key, edge_index in edge_index_dict.items():
             edge_index_dict[key] = map_values(
                 edge_index, self.global_to_local_id
             )
-        node_features_dict = self._create_node_features_dict(observation)
-        node_features_dict, original_ids_dict = self._remove_nodes(
-            node_features_dict, observation["removed_nodes"]
+        # mapping so that ids start from 0 in edge index
+        self._start_from_zero_mapping = self._get_start_from_zero_mappings(
+            original_ids_dict
         )
+        for (type_1, to, type_2), edge_index in edge_index_dict.items():
+            edge_index_dict[(type_1, to, type_2)][0] = map_values(
+                edge_index[0], self._start_from_zero_mapping[type_1]
+            )
+            edge_index_dict[(type_1, to, type_2)][1] = map_values(
+                edge_index[1], self._start_from_zero_mapping[type_2]
+            )
 
         return {
             "edge_index_dict": edge_index_dict,
@@ -179,6 +243,15 @@ class ResourceTaskGraphObservation(ObservationWrapper):
             "original_ids_dict": original_ids_dict,
         }
 
+    @staticmethod
+    def _get_start_from_zero_mappings(
+        original_indices_dict: dict[str, NDArray[np.int32]]
+    ) -> dict[str, dict[int, int]]:
+        mappings = {}
+        for key, indices in original_indices_dict.items():
+            mappings[key] = {idx: i for i, idx in enumerate(indices)}
+        return mappings
+
     def _create_node_features_dict(
         self, observation: ObservationDict
     ) -> dict[str, NDArray]:
@@ -190,14 +263,10 @@ class ResourceTaskGraphObservation(ObservationWrapper):
         Returns:
             Dictionary mapping node type names to node features.
         """
-        node_type_to_feature_type = {
-            NodeType.OPERATION: FeatureType.OPERATIONS,
-            NodeType.MACHINE: FeatureType.MACHINES,
-            NodeType.JOB: FeatureType.JOBS,
-        }
+
         node_features_dict = {}
-        for node_type, feature_type in node_type_to_feature_type.items():
-            if node_type in self.job_shop_graph.nodes_by_type:
+        for node_type, feature_type in _NODE_TYPE_TO_FEATURE_TYPE.items():
+            if self.unwrapped.job_shop_graph.nodes_by_type[node_type]:
                 node_features_dict[feature_type.value] = observation[
                     feature_type.value
                 ]
@@ -210,7 +279,7 @@ class ResourceTaskGraphObservation(ObservationWrapper):
             ]
             job_ids_of_ops = [
                 node.operation.job_id
-                for node in self.job_shop_graph.nodes_by_type[
+                for node in self.unwrapped.job_shop_graph.nodes_by_type[
                     NodeType.OPERATION
                 ]
             ]
@@ -223,9 +292,9 @@ class ResourceTaskGraphObservation(ObservationWrapper):
 
     def _remove_nodes(
         self,
-        node_features_dict: dict[str, NDArray[np.float32]],
+        node_features_dict: dict[str, NDArray[T]],
         removed_nodes: NDArray[np.bool_],
-    ) -> tuple[dict[str, NDArray[np.float32]], dict[str, NDArray[np.int32]]]:
+    ) -> tuple[dict[str, NDArray[T]], dict[str, NDArray[np.int32]]]:
         """Removes nodes from the node features dictionary.
 
         Args:
@@ -235,15 +304,12 @@ class ResourceTaskGraphObservation(ObservationWrapper):
             The node features dictionary with the nodes removed and a
             dictionary containing the original node ids.
         """
-        removed_nodes_dict: dict[str, NDArray[np.float32]] = {}
+        removed_nodes_dict: dict[str, NDArray[T]] = {}
         original_ids_dict: dict[str, NDArray[np.int32]] = {}
-        feature_type_to_node_type = {
-            FeatureType.OPERATIONS.value: NodeType.OPERATION,
-            FeatureType.MACHINES.value: NodeType.MACHINE,
-            FeatureType.JOBS.value: NodeType.JOB,
-        }
         for feature_type, features in node_features_dict.items():
-            node_type = feature_type_to_node_type[feature_type].name.lower()
+            node_type = _FEATURE_TYPE_STR_TO_NODE_TYPE[
+                feature_type
+            ].name.lower()
             if node_type not in self.type_ranges:
                 continue
             start, end = self.type_ranges[node_type]
@@ -256,3 +322,8 @@ class ResourceTaskGraphObservation(ObservationWrapper):
             )[0]
 
         return removed_nodes_dict, original_ids_dict
+
+    @property
+    def unwrapped(self) -> EnvType:
+        """Returns the unwrapped environment."""
+        return self.env  # type: ignore[return-value]

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
+from typing import Any, Dict, Tuple, List, Optional, Type, Union
 
 import matplotlib.pyplot as plt
 import gymnasium as gym
@@ -24,6 +24,8 @@ from job_shop_lib.dispatching import (
 from job_shop_lib.dispatching.feature_observers import (
     FeatureObserverConfig,
     CompositeFeatureObserver,
+    FeatureObserver,
+    FeatureObserverType,
 )
 from job_shop_lib.visualization.gantt import GanttChartCreator
 from job_shop_lib.reinforcement_learning import (
@@ -137,7 +139,14 @@ class SingleJobShopGraphEnv(gym.Env):
     def __init__(
         self,
         job_shop_graph: JobShopGraph,
-        feature_observer_configs: Sequence[FeatureObserverConfig],
+        feature_observer_configs: Sequence[
+            Union[
+                str,
+                FeatureObserverType,
+                Type[FeatureObserver],
+                FeatureObserverConfig,
+            ],
+        ],
         reward_function_config: DispatcherObserverConfig[
             Type[RewardObserver]
         ] = DispatcherObserverConfig(class_type=MakespanReward),

job_shop_lib/reinforcement_learning/_types_and_constants.py

@@ -5,6 +5,7 @@ from enum import Enum
 from typing import TypedDict
 
 import numpy as np
+from numpy.typing import NDArray
 
 from job_shop_lib.dispatching.feature_observers import FeatureType
 from job_shop_lib.visualization.gantt import (
@@ -35,27 +36,27 @@ class ObservationSpaceKey(str, Enum):
 class _ObservationDictRequired(TypedDict):
     """Required fields for the observation dictionary."""
 
-    removed_nodes: np.ndarray
-    edge_index: np.ndarray
+    removed_nodes: NDArray[np.bool_]
+    edge_index: NDArray[np.int32]
 
 
 class _ObservationDictOptional(TypedDict, total=False):
     """Optional fields for the observation dictionary."""
 
-    operations: np.ndarray
-    jobs: np.ndarray
-    machines: np.ndarray
+    operations: NDArray[np.float32]
+    jobs: NDArray[np.float32]
+    machines: NDArray[np.float32]
 
 
 class ObservationDict(_ObservationDictRequired, _ObservationDictOptional):
     """A dictionary containing the observation of the environment.
 
     Required fields:
-        removed_nodes (np.ndarray): Binary vector indicating removed nodes.
-        edge_index (np.ndarray): Edge list in COO format.
+        removed_nodes: Binary vector indicating removed nodes.
+        edge_index: Edge list in COO format.
 
     Optional fields:
-        operations (np.ndarray): Matrix of operation features.
-        jobs (np.ndarray): Matrix of job features.
-        machines (np.ndarray): Matrix of machine features.
+        operations: Matrix of operation features.
+        jobs: Matrix of job features.
+        machines: Matrix of machine features.
     """

job_shop_lib/reinforcement_learning/_utils.py

@@ -6,6 +6,7 @@ import numpy as np
 from numpy.typing import NDArray
 
 from job_shop_lib.exceptions import ValidationError
+from job_shop_lib.dispatching import OptimalOperationsObserver
 
 T = TypeVar("T", bound=np.number)
 
@@ -164,6 +165,34 @@ def map_values(array: NDArray[T], mapping: dict[int, int]) -> NDArray[T]:
         ) from e
 
 
+def get_optimal_actions(
+    optimal_ops_observer: OptimalOperationsObserver,
+    available_operations_with_ids: list[tuple[int, int, int]],
+) -> dict[tuple[int, int, int], int]:
+    """Indicates if each action is optimal according to a
+    :class:`~job_shop_lib.dispatching.OptimalOperationsObserver` instance.
+
+    Args:
+        optimal_ops_observer: The observer that provides optimal operations.
+        available_operations_with_ids: List of available operations with their
+        IDs (operation_id, machine_id, job_id).
+
+    Returns:
+        A dictionary mapping each tuple
+        (operation_id, machine_id, job_id) in the available actions to a binary
+        indicator (1 if optimal, 0 otherwise).
+    """
+    optimal_actions = {}
+    optimal_ops = optimal_ops_observer.optimal_available
+    optimal_ops_ids = [
+        (op.operation_id, op.machine_id, op.job_id) for op in optimal_ops
+    ]
+    for operation_id, machine_id, job_id in available_operations_with_ids:
+        is_optimal = (operation_id, machine_id, job_id) in optimal_ops_ids
+        optimal_actions[(operation_id, machine_id, job_id)] = int(is_optimal)
+    return optimal_actions
+
+
 if __name__ == "__main__":
     import doctest
 

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
+from typing import Sequence, Protocol, Optional, List, Any
 
 import imageio
 import matplotlib.pyplot as plt
@@ -68,6 +68,7 @@ def get_partial_gantt_chart_plotter(
     title: Optional[str] = None,
     cmap: str = "viridis",
     show_available_operations: bool = False,
+    **kwargs: Any,
 ) -> PartialGanttChartPlotter:
     """Returns a function that plots a Gantt chart for an unfinished schedule.
 
@@ -76,6 +77,8 @@ def get_partial_gantt_chart_plotter(
         cmap: The name of the colormap to use.
         show_available_operations:
             Whether to show the available operations in the Gantt chart.
+        **kwargs: Additional keyword arguments to pass to the
+            :func:`plot_gantt_chart` function.
 
     Returns:
         A function that plots a Gantt chart for a schedule. The function takes
@@ -97,7 +100,7 @@ def get_partial_gantt_chart_plotter(
         current_time: Optional[int] = None,
     ) -> Figure:
         fig, ax = plot_gantt_chart(
-            schedule, title=title, cmap_name=cmap, xlim=makespan
+            schedule, title=title, cmap_name=cmap, xlim=makespan, **kwargs
         )
 
         if show_available_operations and available_operations is not None:

job_shop_lib/visualization/graphs/_plot_disjunctive_graph.py

@@ -7,6 +7,7 @@ import warnings
 import copy
 
 import matplotlib
+import matplotlib.colors
 import matplotlib.pyplot as plt
 import networkx as nx
 from networkx.drawing.nx_agraph import graphviz_layout
@@ -66,6 +67,9 @@ 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,
     color_map: str = "Dark2_r",
     disjunctive_edge_color: str = "red",
     conjunctive_edge_color: str = "black",
@@ -114,6 +118,12 @@ def plot_disjunctive_graph(
             with their duration.
         node_font_color:
             The color of the node labels (default is ``"white"``).
+        machine_colors:
+            A dictionary that maps machine ids to colors. If not provided,
+            the colors are generated using the ``color_map``. If provided,
+            the colors are used as the base for the node colors. The
+            dictionary should have the form ``{machine_id: (r, g, b, a)}``.
+            For source and sink nodes use ``-1`` as the machine id.
         color_map:
             The color map to use for the nodes (default is ``"Dark2_r"``).
         disjunctive_edge_color:
@@ -229,12 +239,40 @@ def plot_disjunctive_graph(
 
     # Draw nodes
     # ----------
-    node_colors = [
-        _get_node_color(node)
-        for node in job_shop_graph.nodes
-        if not job_shop_graph.is_removed(node.node_id)
-    ]
-    cmap_func = matplotlib.colormaps.get_cmap(color_map)
+    operation_nodes = job_shop_graph.nodes_by_type[NodeType.OPERATION]
+    cmap_func: Optional[matplotlib.colors.Colormap] = None
+    if machine_colors is None:
+        machine_colors = {}
+        cmap_func = matplotlib.colormaps.get_cmap(color_map)
+        remaining_machines = job_shop_graph.instance.num_machines
+        for operation_node in operation_nodes:
+            if job_shop_graph.is_removed(operation_node.node_id):
+                continue
+            machine_id = operation_node.operation.machine_id
+            if machine_id not in machine_colors:
+                machine_colors[machine_id] = cmap_func(
+                    (_get_node_color(operation_node) + 1)
+                    / job_shop_graph.instance.num_machines
+                )
+                remaining_machines -= 1
+            if remaining_machines == 0:
+                break
+        node_colors: list[Any] = [
+            _get_node_color(node)
+            for node in job_shop_graph.nodes
+            if not job_shop_graph.is_removed(node.node_id)
+        ]
+    else:
+        node_colors = []
+        for node in job_shop_graph.nodes:
+            if job_shop_graph.is_removed(node.node_id):
+                continue
+            if node.node_type == NodeType.OPERATION:
+                machine_id = node.operation.machine_id
+            else:
+                machine_id = -1
+            node_colors.append(machine_colors[machine_id])
+
     nx.draw_networkx_nodes(
         job_shop_graph.graph,
         pos,
@@ -292,24 +330,20 @@ def plot_disjunctive_graph(
 
     # Draw node labels
     # ----------------
-    operation_nodes = job_shop_graph.nodes_by_type[NodeType.OPERATION]
     labels = {}
-    source_node = job_shop_graph.nodes_by_type[NodeType.SOURCE][0]
-    labels[source_node] = start_node_label
-
-    sink_node = job_shop_graph.nodes_by_type[NodeType.SINK][0]
-    labels[sink_node] = end_node_label
-    machine_colors: dict[int, Tuple[float, float, float, float]] = {}
+    if job_shop_graph.nodes_by_type[NodeType.SOURCE]:
+        source_node = job_shop_graph.nodes_by_type[NodeType.SOURCE][0]
+        if not job_shop_graph.is_removed(source_node.node_id):
+            labels[source_node] = start_node_label
+    if job_shop_graph.nodes_by_type[NodeType.SINK]:
+        sink_node = job_shop_graph.nodes_by_type[NodeType.SINK][0]
+        # check if the sink node is removed
+        if not job_shop_graph.is_removed(sink_node.node_id):
+            labels[sink_node] = end_node_label
     for operation_node in operation_nodes:
         if job_shop_graph.is_removed(operation_node.node_id):
             continue
         labels[operation_node] = operation_node_labeler(operation_node)
-        machine_id = operation_node.operation.machine_id
-        if machine_id not in machine_colors:
-            machine_colors[machine_id] = cmap_func(
-                (_get_node_color(operation_node) + 1)
-                / job_shop_graph.instance.num_machines
-            )
 
     nx.draw_networkx_labels(
         job_shop_graph.graph,

{job_shop_lib-1.0.0b4.dist-info → job_shop_lib-1.0.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: job-shop-lib
-Version: 1.0.0b4
+Version: 1.0.1
 Summary: An easy-to-use and modular Python library for the Job Shop Scheduling Problem (JSSP)
 License: MIT
 Author: Pabloo22
@@ -12,7 +12,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Provides-Extra: pygraphviz
-Requires-Dist: gymnasium (>=0.29.1,<0.30.0)
+Requires-Dist: gymnasium (>=1.0.0,<2.0.0)
 Requires-Dist: imageio[ffmpeg] (>=2.34.1,<3.0.0)
 Requires-Dist: matplotlib (>=3,<4)
 Requires-Dist: networkx (>=3,<4)
@@ -48,7 +48,7 @@ See the [documentation](https://job-shop-lib.readthedocs.io/en/latest/) for more
 
 JobShopLib is distributed on [PyPI](https://pypi.org/project/job-shop-lib/) and it supports Python 3.10+.
 
-You can install the latest stable version (version 0.5.1) using `pip`:
+You can install the latest stable version using `pip`:
 
 ```bash
 pip install job-shop-lib
@@ -57,13 +57,7 @@ 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.0b4
-```
-
-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 familiarize yourself with new changes (see the [latest pull requests](https://github.com/Pabloo22/job_shop_lib/pulls?q=is%3Apr+is%3Aclosed)). There is a [documentation page](https://job-shop-lib.readthedocs.io/en/latest/) for versions 1.0.0a3 and onward.
+There is a [documentation page](https://job-shop-lib.readthedocs.io/en/latest/) for versions 1.0.0a3 and onward. See see the [latest pull requests](https://github.com/Pabloo22/job_shop_lib/pulls?q=is%3Apr+is%3Aclosed) for the latest changes.
 
 <!-- end installation -->