job-shop-lib 1.0.0b2__py3-none-any.whl → 1.0.0b4__py3-none-any.whl

job_shop_lib/__init__.py

@@ -19,7 +19,7 @@ from job_shop_lib._schedule import Schedule
 from job_shop_lib._base_solver import BaseSolver, Solver
 
 
-__version__ = "1.0.0-b.2"
+__version__ = "1.0.0-b.4"
 
 __all__ = [
     "Operation",

job_shop_lib/graphs/__init__.py

@@ -8,9 +8,9 @@ The main classes and functions available in this package are:
     NodeType
     build_disjunctive_graph
     build_solved_disjunctive_graph
-    build_agent_task_graph
-    build_complete_agent_task_graph
-    build_agent_task_graph_with_jobs
+    build_resource_task_graph
+    build_complete_resource_task_graph
+    build_resource_task_graph_with_jobs
 
 """
 

job_shop_lib/reinforcement_learning/__init__.py

@@ -12,6 +12,9 @@
     IdleTimeReward
     RenderConfig
     add_padding
+    create_edge_type_dict
+    ResourceTaskGraphObservation
+    ResourceTaskGraphObservationDict
 
 """
 
@@ -27,7 +30,11 @@ from job_shop_lib.reinforcement_learning._reward_observers import (
     IdleTimeReward,
 )
 
-from job_shop_lib.reinforcement_learning._utils import add_padding
+from job_shop_lib.reinforcement_learning._utils import (
+    add_padding,
+    create_edge_type_dict,
+    map_values,
+)
 
 from job_shop_lib.reinforcement_learning._single_job_shop_graph_env import (
     SingleJobShopGraphEnv,
@@ -35,6 +42,9 @@ from job_shop_lib.reinforcement_learning._single_job_shop_graph_env import (
 from job_shop_lib.reinforcement_learning._multi_job_shop_graph_env import (
     MultiJobShopGraphEnv,
 )
+from ._resource_task_graph_observation import (
+    ResourceTaskGraphObservation, ResourceTaskGraphObservationDict
+)
 
 
 __all__ = [
@@ -47,4 +57,8 @@ __all__ = [
     "ObservationDict",
     "add_padding",
     "MultiJobShopGraphEnv",
+    "create_edge_type_dict",
+    "ResourceTaskGraphObservation",
+    "map_values",
+    "ResourceTaskGraphObservationDict",
 ]

job_shop_lib/reinforcement_learning/_multi_job_shop_graph_env.py

@@ -235,13 +235,13 @@ class MultiJobShopGraphEnv(gym.Env):
     @ready_operations_filter.setter
     def ready_operations_filter(
         self,
-        pruning_function: Callable[
+        ready_operations_filter: Callable[
             [Dispatcher, List[Operation]], List[Operation]
         ],
     ) -> None:
         """Sets the ready operations filter."""
         self.single_job_shop_graph_env.dispatcher.ready_operations_filter = (
-            pruning_function
+            ready_operations_filter
         )
 
     @property

job_shop_lib/reinforcement_learning/_resource_task_graph_observation.py

@@ -0,0 +1,258 @@
+"""Contains wrappers for the environments."""
+
+from typing import TypeVar, TypedDict
+from gymnasium import ObservationWrapper
+import numpy as np
+from numpy.typing import NDArray
+
+from job_shop_lib.reinforcement_learning import (
+    ObservationDict,
+    SingleJobShopGraphEnv,
+    MultiJobShopGraphEnv,
+    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.dispatching.feature_observers import FeatureType
+
+T = TypeVar("T", bound=np.number)
+
+
+class ResourceTaskGraphObservationDict(TypedDict):
+    """Represents a dictionary for resource task graph observations."""
+
+    edge_index_dict: dict[str, NDArray[np.int64]]
+    node_features_dict: dict[str, NDArray[np.float32]]
+    original_ids_dict: dict[str, NDArray[np.int32]]
+
+
+# pylint: disable=line-too-long
+class ResourceTaskGraphObservation(ObservationWrapper):
+    """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).
+
+    In particular, the ``edge_index`` is converted into a ``edge_index_dict``
+    with keys ``(node_type_i, "to", node_type_j)``. The ``node_type_i`` and
+    ``node_type_j`` are the node types of the source and target nodes,
+    respectively.
+
+    Attributes:
+        global_to_local_id: A dictionary mapping global node IDs to local node
+            IDs for each node type.
+        type_ranges: A dictionary mapping node type names to (start, end) index
+            ranges.
+
+    Args:
+        env: The environment to wrap.
+    """
+
+    def __init__(self, env: SingleJobShopGraphEnv | MultiJobShopGraphEnv):
+        super().__init__(env)
+        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"
+        )
+
+    def step(self, action: tuple[int, int]):
+        """Takes a step in the environment.
+
+        Args:
+            action:
+                The action to take. The action is a tuple of two integers
+                (job_id, machine_id):
+                the job ID and the machine ID in which to schedule the
+                operation.
+
+        Returns:
+            A tuple containing the following elements:
+
+            - The observation of the environment.
+            - The reward obtained.
+            - Whether the environment is done.
+            - Whether the episode was truncated (always False).
+            - A dictionary with additional information. The dictionary
+              contains the following keys: "feature_names", the names of the
+              features in the observation; and "available_operations_with_ids",
+              a list of available actions in the form of (operation_id,
+              machine_id, job_id).
+        """
+        observation, reward, done, truncated, info = self.env.step(action)
+        return self.observation(observation), reward, done, truncated, info
+
+    def reset(self, *, seed: int | None = None, options: dict | None = None):
+        """Resets the environment.
+
+        Args:
+            seed:
+                Added to match the signature of the parent class. It is not
+                used in this method.
+            options:
+                Additional options to pass to the environment. Not used in
+                this method.
+
+        Returns:
+            A tuple containing the following elements:
+
+            - The observation of the environment.
+            - A dictionary with additional information, keys
+                include: "feature_names", the names of the features in the
+                observation; and "available_operations_with_ids", a list of
+                available a list of available actions in the form of
+                (operation_id, machine_id, job_id).
+        """
+        observation, info = self.env.reset()
+        return self.observation(observation), info
+
+    def _compute_id_mappings(self) -> dict[int, int]:
+        """Computes mappings from global node IDs to type-local IDs.
+
+        Returns:
+            A dictionary mapping global node IDs to local node IDs for each
+            node type.
+        """
+        mappings = {}
+        for node_type in NodeType:
+            type_nodes = self.job_shop_graph.nodes_by_type[node_type]
+            if not type_nodes:
+                continue
+            # Create mapping from global ID to local ID
+            # (0 to len(type_nodes)-1)
+            type_mapping = {
+                node.node_id: local_id
+                for local_id, node in enumerate(type_nodes)
+            }
+            mappings.update(type_mapping)
+
+        return mappings
+
+    def _compute_node_type_ranges(self) -> dict[str, tuple[int, int]]:
+        """Computes index ranges for each node type.
+
+        Returns:
+            Dictionary mapping node type names to (start, end) index ranges
+        """
+        type_ranges = {}
+        for node_type in NodeType:
+            type_nodes = self.job_shop_graph.nodes_by_type[node_type]
+            if not type_nodes:
+                continue
+            start = min(node.node_id for node in type_nodes)
+            end = max(node.node_id for node in type_nodes) + 1
+            type_ranges[node_type.name.lower()] = (start, end)
+
+        return type_ranges
+
+    def observation(self, observation: ObservationDict):
+        edge_index_dict = create_edge_type_dict(
+            observation["edge_index"],
+            type_ranges=self.type_ranges,
+            relationship="to",
+        )
+        # 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"]
+        )
+
+        return {
+            "edge_index_dict": edge_index_dict,
+            "node_features_dict": node_features_dict,
+            "original_ids_dict": original_ids_dict,
+        }
+
+    def _create_node_features_dict(
+        self, observation: ObservationDict
+    ) -> dict[str, NDArray]:
+        """Creates a dictionary of node features for each node type.
+
+        Args:
+            observation: The observation dictionary.
+
+        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:
+                node_features_dict[feature_type.value] = observation[
+                    feature_type.value
+                ]
+                continue
+            if feature_type != FeatureType.JOBS:
+                continue
+            assert FeatureType.OPERATIONS.value in observation
+            job_features = observation[
+                feature_type.value  # type: ignore[literal-required]
+            ]
+            job_ids_of_ops = [
+                node.operation.job_id
+                for node in self.job_shop_graph.nodes_by_type[
+                    NodeType.OPERATION
+                ]
+            ]
+            job_features_expanded = job_features[job_ids_of_ops]
+            operation_features = observation[FeatureType.OPERATIONS.value]
+            node_features_dict[FeatureType.OPERATIONS.value] = np.concatenate(
+                (operation_features, job_features_expanded), axis=1
+            )
+        return node_features_dict
+
+    def _remove_nodes(
+        self,
+        node_features_dict: dict[str, NDArray[np.float32]],
+        removed_nodes: NDArray[np.bool_],
+    ) -> tuple[dict[str, NDArray[np.float32]], dict[str, NDArray[np.int32]]]:
+        """Removes nodes from the node features dictionary.
+
+        Args:
+            node_features_dict: The node features dictionary.
+
+        Returns:
+            The node features dictionary with the nodes removed and a
+            dictionary containing the original node ids.
+        """
+        removed_nodes_dict: dict[str, NDArray[np.float32]] = {}
+        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()
+            if node_type not in self.type_ranges:
+                continue
+            start, end = self.type_ranges[node_type]
+            removed_nodes_of_this_type = removed_nodes[start:end]
+            removed_nodes_dict[node_type] = features[
+                ~removed_nodes_of_this_type
+            ]
+            original_ids_dict[node_type] = np.where(
+                ~removed_nodes_of_this_type
+            )[0]
+
+        return removed_nodes_dict, original_ids_dict

job_shop_lib/reinforcement_learning/_single_job_shop_graph_env.py

@@ -243,8 +243,27 @@ class SingleJobShopGraphEnv(gym.Env):
         *,
         seed: Optional[int] = None,
         options: Optional[Dict[str, Any]] = None,
-    ) -> Tuple[ObservationDict, dict]:
-        """Resets the environment."""
+    ) -> Tuple[ObservationDict, dict[str, Any]]:
+        """Resets the environment.
+
+        Args:
+            seed:
+                Added to match the signature of the parent class. It is not
+                used in this method.
+            options:
+                Additional options to pass to the environment. Not used in
+                this method.
+
+        Returns:
+            A tuple containing the following elements:
+
+            - The observation of the environment.
+            - A dictionary with additional information, keys
+                include: "feature_names", the names of the features in the
+                observation; and "available_operations_with_ids", a list of
+                available a list of available actions in the form of
+                (operation_id, machine_id, job_id).
+        """
         super().reset(seed=seed, options=options)
         self.dispatcher.reset()
         obs = self.get_observation()

job_shop_lib/reinforcement_learning/_utils.py

@@ -1,6 +1,6 @@
 """Utility functions for reinforcement learning."""
 
-from typing import TypeVar, Any, Tuple, Optional, Type
+from typing import TypeVar, Any, Type
 
 import numpy as np
 from numpy.typing import NDArray
@@ -12,9 +12,9 @@ T = TypeVar("T", bound=np.number)
 
 def add_padding(
     array: NDArray[Any],
-    output_shape: Tuple[int, ...],
+    output_shape: tuple[int, ...],
     padding_value: float = -1,
-    dtype: Optional[Type[T]] = None,
+    dtype: Type[T] | None = None,
 ) -> NDArray[T]:
     """Adds padding to the array.
 
@@ -90,6 +90,80 @@ def add_padding(
     return padded_array
 
 
+def create_edge_type_dict(
+    edge_index: NDArray[T],
+    type_ranges: dict[str, tuple[int, int]],
+    relationship: str = "to",
+) -> dict[tuple[str, str, str], NDArray[T]]:
+    """Organizes edges based on node types.
+
+    Args:
+        edge_index:
+            numpy array of shape (2, E) where E is number of edges
+        type_ranges: dict[str, tuple[int, int]]
+            Dictionary mapping type names to their corresponding index ranges
+            [start, end) in the ``edge_index`` array.
+        relationship:
+            A string representing the relationship type between nodes.
+
+    Returns:
+        A dictionary with keys (type_i, relationship, type_j) and values as
+        edge indices
+    """
+    edge_index_dict: dict[tuple[str, str, str], NDArray] = {}
+    for type_name_i, (start_i, end_i) in type_ranges.items():
+        for type_name_j, (start_j, end_j) in type_ranges.items():
+            key: tuple[str, str, str] = (
+                type_name_i,
+                relationship,
+                type_name_j,
+            )
+            # Find edges where source is in type_i and target is in type_j
+            mask = (
+                (edge_index[0] >= start_i)
+                & (edge_index[0] < end_i)
+                & (edge_index[1] >= start_j)
+                & (edge_index[1] < end_j)
+            )
+            edge_index_dict[key] = edge_index[:, mask]
+
+    return edge_index_dict
+
+
+def map_values(array: NDArray[T], mapping: dict[int, int]) -> NDArray[T]:
+    """Maps values in an array using a mapping.
+
+    Args:
+        array:
+            An NumPy array.
+
+    Returns:
+        A NumPy array where each element has been replaced by its
+        corresponding value from the mapping.
+
+    Raises:
+        ValidationError:
+            If the array contains values that are not in the mapping.
+
+    Examples:
+        >>> map_values(np.array([1, 2, 3]), {1: 10, 2: 20, 3: 30})
+        array([10, 20, 30])
+
+        >>> map_values(np.array([1, 2]), {1: 10, 2: 10, 3: 30})
+        array([10, 10])
+
+    """
+    if array.size == 0:
+        return array
+    try:
+        vectorized_mapping = np.vectorize(mapping.get)
+        return vectorized_mapping(array)
+    except TypeError as e:
+        raise ValidationError(
+            "The array contains values that are not in the mapping."
+        ) from e
+
+
 if __name__ == "__main__":
     import doctest
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: job-shop-lib
-Version: 1.0.0b2
+Version: 1.0.0b4
 Summary: An easy-to-use and modular Python library for the Job Shop Scheduling Problem (JSSP)
 License: MIT
 Author: Pabloo22
@@ -60,7 +60,7 @@ See [this](https://colab.research.google.com/drive/1XV_Rvq1F2ns6DFG8uNj66q_rcoww
 Version 1.0.0 is currently in beta stage and can be installed with:
 
 ```bash
-pip install job-shop-lib==1.0.0b2
+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.
@@ -89,11 +89,7 @@ Although this version is not stable and may contain breaking changes in subseque
   - **Agent-Task Graphs**: Encode instances as agent-task graphs (introduced in [ScheduleNet paper](https://arxiv.org/abs/2106.03051)). See [Agent-Task Graph](https://github.com/Pabloo22/job_shop_lib/blob/main/docs/source/examples/07-Agent-Task-Graph.ipynb).
   - Build your own custom graphs with the `JobShopGraph` class.
 
-<<<<<<< HEAD
 - **Gymnasium Environments**: Two environments for solving the problem with graph neural networks (GNNs) or any other method, and reinforcement learning (RL). See [SingleJobShopGraphEnv](https://github.com/Pabloo22/job_shop_lib/blob/main/docs/source/examples/09-SingleJobShopGraphEnv.ipynb) and [MultiJobShopGraphEnv](https://github.com/Pabloo22/job_shop_lib/blob/main/docs/source/examples/10-MultiJobShopGraphEnv.ipynb).
-=======
-- **Gymnasium Environments**: Two environments for solving the problem with Graph Neural Networks (GNNs) or any other method, and Reinforcement Learning (RL). See [SingleJobShopGraphEnv](https://github.com/Pabloo22/job_shop_lib/blob/main/docs/source/examples/09-SingleJobShopGraphEnv.ipynb) and [MultiJobShopGraphEnv](https://github.com/Pabloo22/job_shop_lib/blob/main/docs/source/examples/10-MultiJobShopGraphEnv.ipynb).
->>>>>>> 031bdf3 ([Docs] Update links in README to point to the correct GitHub URLs for tutorials and examples)
 
 <!-- end key features -->
 

{job_shop_lib-1.0.0b2.dist-info → job_shop_lib-1.0.0b4.dist-info}/RECORD

@@ -1,4 +1,4 @@
-job_shop_lib/__init__.py,sha256=xXYzjYqn-98QKOMQ4_fOBZYQ6Z6GUydDW5BNXiVSRCE,643
+job_shop_lib/__init__.py,sha256=I9Ifdoq10hPCyLVpLFUKHTjSldDRCqJx-raUQKid0aw,643
 job_shop_lib/_base_solver.py,sha256=p17XmtufNc9Y481cqZUT45pEkUmmW1HWG53dfhIBJH8,1363
 job_shop_lib/_job_shop_instance.py,sha256=hNQGSJj0rEQpS-YhzwWmM6QzCWp6r--89jkghSgLvUs,18380
 job_shop_lib/_operation.py,sha256=hx2atpP8LPj9fvxpZIfhBFr9Uq6JP-MKAX5JzTvFXso,3847
@@ -40,7 +40,7 @@ job_shop_lib/generation/_general_instance_generator.py,sha256=e-NDkH-NoCwa14oADj
 job_shop_lib/generation/_instance_generator.py,sha256=VV0OKX4JgFq3I1EY6s3LrOdPjM3v4lH6S1hkUebTkFQ,4615
 job_shop_lib/generation/_transformations.py,sha256=X-hTAJVIHZ3bmF1rqS0zCit8r5SGpHpV8Fcl92fejow,5336
 job_shop_lib/generation/_utils.py,sha256=cBhGILE0FE3TqvWoHqpaFEffO8D2fb869pF-BdMlYsg,3617
-job_shop_lib/graphs/__init__.py,sha256=zw4aOE-7QF8Lt8316rCUwOEAGqznjiijumTlGqBmfuw,1840
+job_shop_lib/graphs/__init__.py,sha256=RI9vGUR_89X34UoHpl1HYZpxT8JOWg8dwZTe5ImDCVg,1849
 job_shop_lib/graphs/_build_disjunctive_graph.py,sha256=UbUYdeQaaeEqLchcKJGHEFGl4wElfGLb1o_R-u8wqnA,5120
 job_shop_lib/graphs/_build_resource_task_graphs.py,sha256=GHUHkUNPxVf1miScgPPMe2YqlXFEMxIy5cDhNw7OZ1E,6954
 job_shop_lib/graphs/_constants.py,sha256=K-GeVvh_DTWpo1KOX1clmxWS_pkUJbq19yOBmrCVIxI,1086
@@ -50,12 +50,13 @@ job_shop_lib/graphs/graph_updaters/__init__.py,sha256=UhnZL55e3cAv7hVetB6bRmIOn8
 job_shop_lib/graphs/graph_updaters/_graph_updater.py,sha256=j1f7iWsa62GVszK2BPaMxnKBCEGWa9owm8g4VWUje8w,1967
 job_shop_lib/graphs/graph_updaters/_residual_graph_updater.py,sha256=SfgmDyMwfW56OBjJPaU76c42IsX5qx9j-eMtrv0DjKk,6047
 job_shop_lib/graphs/graph_updaters/_utils.py,sha256=X5YfwJA1CCgpm1r9C036Gal2CkDh2SSak7wl7TbdjHw,704
-job_shop_lib/reinforcement_learning/__init__.py,sha256=gOY-C6BMeFr3084MKMMbW0CoK7gMsaOYNsgnYuepswQ,1033
-job_shop_lib/reinforcement_learning/_multi_job_shop_graph_env.py,sha256=ib1Y6cItVvId4PfesiQ0XKbh9y6h8LVhD0gYDO4wSlk,15732
+job_shop_lib/reinforcement_learning/__init__.py,sha256=opqJyVJ6VPyeaQOQr4hmUTkiUAXOi5tbyCnuNw5jLTI,1421
+job_shop_lib/reinforcement_learning/_multi_job_shop_graph_env.py,sha256=memQefVWqatRNodt8hBXVvFcgQKJRmnuB8AWqiDl8_k,15746
+job_shop_lib/reinforcement_learning/_resource_task_graph_observation.py,sha256=C4sEssy4TqHdr6nLJlg7Cdg48RBRSvmkYDzG1vaTf6U,9920
 job_shop_lib/reinforcement_learning/_reward_observers.py,sha256=iWHccnujeAKyTQn2ilQ4BhcEccoSTyJqQ5yOiP5GG_Y,2984
-job_shop_lib/reinforcement_learning/_single_job_shop_graph_env.py,sha256=DZnXeXmzMGKq-vwFhxukmSDN1UyrkUfbnjpjFtC9_Bs,15845
+job_shop_lib/reinforcement_learning/_single_job_shop_graph_env.py,sha256=3mljeI4k9haLDuDZZhv4NcLpb1_xOlQNdEqMoRsh6bw,16592
 job_shop_lib/reinforcement_learning/_types_and_constants.py,sha256=xozdM_Wabdbe9e1a769p5980OSNBwQqc9yyaSGW2ODQ,1743
-job_shop_lib/reinforcement_learning/_utils.py,sha256=ksg2ghSncxd0K3AR5hGS5PQejjd-Hgx6LGtXX_oatOc,2523
+job_shop_lib/reinforcement_learning/_utils.py,sha256=giikAj9Xl2f_cYq_AKCrgHn79TRLfGhYNqXz7bEnKuk,4827
 job_shop_lib/visualization/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 job_shop_lib/visualization/gantt/__init__.py,sha256=HGXwRgDuMAldqU0JBdiZCd5e79XBz1r96qHeDVlzE54,1145
 job_shop_lib/visualization/gantt/_gantt_chart_creator.py,sha256=LTsVhpB1Fb_2o08HRZPPXSekwzR7fyTSC6h549XMqhU,8638
@@ -64,7 +65,7 @@ job_shop_lib/visualization/gantt/_plot_gantt_chart.py,sha256=9-NSSNsVcW8gYLZtAuF
 job_shop_lib/visualization/graphs/__init__.py,sha256=282hZFg07EyQu4HVt4GzFfYnY6ZF376IMjnWZ5eg0ZQ,611
 job_shop_lib/visualization/graphs/_plot_disjunctive_graph.py,sha256=4VBMYiFXXkCGSnGYN9iqNtWrbLJQxAMHojPHhAbdA0s,14387
 job_shop_lib/visualization/graphs/_plot_resource_task_graph.py,sha256=RgJqHS5hJh3KkyaLbtpG_bER981BFRwGpflz7I7gS64,13271
-job_shop_lib-1.0.0b2.dist-info/LICENSE,sha256=9mggivMGd5taAu3xbmBway-VQZMBzurBGHofFopvUsQ,1069
-job_shop_lib-1.0.0b2.dist-info/METADATA,sha256=_6waZfwgtsPOyvZ5rw18aulHrqEOJji5jcde9NrQBpg,16978
-job_shop_lib-1.0.0b2.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-job_shop_lib-1.0.0b2.dist-info/RECORD,,
+job_shop_lib-1.0.0b4.dist-info/LICENSE,sha256=9mggivMGd5taAu3xbmBway-VQZMBzurBGHofFopvUsQ,1069
+job_shop_lib-1.0.0b4.dist-info/METADATA,sha256=9tz-kjhEJIDvEjr5B69IOBI6_gREvO53E1sAN0iKFQk,16424
+job_shop_lib-1.0.0b4.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+job_shop_lib-1.0.0b4.dist-info/RECORD,,