job-shop-lib 0.5.1__py3-none-any.whl → 1.0.0__py3-none-any.whl

job_shop_lib/graphs/job_shop_graph.py

@@ -1,202 +0,0 @@
-"""Home of the `JobShopGraph` class."""
-
-import collections
-import networkx as nx
-
-from job_shop_lib import JobShopInstance, JobShopLibError
-from job_shop_lib.graphs import Node, NodeType
-
-
-NODE_ATTR = "node"
-
-
-# pylint: disable=too-many-instance-attributes
-class JobShopGraph:
-    """Data structure to represent a `JobShopInstance` as a graph.
-
-    Provides a comprehensive graph-based representation of a job shop
-    scheduling problem, utilizing the `networkx` library to model the complex
-    relationships between jobs, operations, and machines. This class transforms
-    the abstract scheduling problem into a directed graph, where various
-    entities (jobs, machines, and operations) are nodes, and the dependencies
-    (such as operation order within a job or machine assignment) are edges.
-
-    This transformation allows for the application of graph algorithms
-    to analyze and solve scheduling problems.
-
-    Attributes:
-        instance:
-            The job shop instance encapsulated by this graph.
-        graph:
-            The directed graph representing the job shop, where nodes are
-                operations, machines, jobs, or abstract concepts like global,
-                source, and sink, with edges indicating dependencies.
-    """
-
-    def __init__(self, instance: JobShopInstance):
-        """Initializes the graph with the given instance.
-
-        Nodes of type `OPERATION` are added to the graph based on the
-        operations of the instance.
-
-        Args:
-            instance:
-                The job shop instance that the graph represents.
-        """
-        self.graph = nx.DiGraph()
-        self.instance = instance
-
-        self._nodes: list[Node] = []
-        self._nodes_by_type: dict[NodeType, list[Node]] = (
-            collections.defaultdict(list)
-        )
-        self._nodes_by_machine: list[list[Node]] = [
-            [] for _ in range(instance.num_machines)
-        ]
-        self._nodes_by_job: list[list[Node]] = [
-            [] for _ in range(instance.num_jobs)
-        ]
-        self._next_node_id = 0
-        self.removed_nodes: list[bool] = []
-        self._add_operation_nodes()
-
-    @property
-    def nodes(self) -> list[Node]:
-        """List of all nodes added to the graph.
-
-        It may contain nodes that have been removed from the graph.
-        """
-        return self._nodes
-
-    @property
-    def nodes_by_type(self) -> dict[NodeType, list[Node]]:
-        """Dictionary mapping node types to lists of nodes.
-
-        It may contain nodes that have been removed from the graph.
-        """
-        return self._nodes_by_type
-
-    @property
-    def nodes_by_machine(self) -> list[list[Node]]:
-        """List of lists mapping machine ids to operation nodes.
-
-        It may contain nodes that have been removed from the graph.
-        """
-        return self._nodes_by_machine
-
-    @property
-    def nodes_by_job(self) -> list[list[Node]]:
-        """List of lists mapping job ids to operation nodes.
-
-        It may contain nodes that have been removed from the graph.
-        """
-        return self._nodes_by_job
-
-    @property
-    def num_edges(self) -> int:
-        """Number of edges in the graph."""
-        return self.graph.number_of_edges()
-
-    @property
-    def num_job_nodes(self) -> int:
-        """Number of job nodes in the graph."""
-        return len(self._nodes_by_type[NodeType.JOB])
-
-    def _add_operation_nodes(self) -> None:
-        """Adds operation nodes to the graph."""
-        for job in self.instance.jobs:
-            for operation in job:
-                node = Node(node_type=NodeType.OPERATION, operation=operation)
-                self.add_node(node)
-
-    def add_node(self, node_for_adding: Node) -> None:
-        """Adds a node to the graph and updates relevant class attributes.
-
-        This method assigns a unique identifier to the node, adds it to the
-        graph, and updates the nodes list and the nodes_by_type dictionary. If
-        the node is of type `OPERATION`, it also updates `nodes_by_job` and
-        `nodes_by_machine` based on the operation's job_id and machine_ids.
-
-        Args:
-            node_for_adding (Node): The node to be added to the graph.
-
-        Raises:
-            ValueError: If the node type is unsupported or if required
-            attributes for the node type are missing.
-
-        Note:
-            This method directly modifies the graph attribute as well as
-            several other class attributes. Thus, adding nodes to the graph
-            should be done exclusively through this method to avoid
-            inconsistencies.
-        """
-        node_for_adding.node_id = self._next_node_id
-        self.graph.add_node(
-            node_for_adding.node_id, **{NODE_ATTR: node_for_adding}
-        )
-        self._nodes_by_type[node_for_adding.node_type].append(node_for_adding)
-        self._nodes.append(node_for_adding)
-        self._next_node_id += 1
-        self.removed_nodes.append(False)
-
-        if node_for_adding.node_type == NodeType.OPERATION:
-            operation = node_for_adding.operation
-            self._nodes_by_job[operation.job_id].append(node_for_adding)
-            for machine_id in operation.machines:
-                self._nodes_by_machine[machine_id].append(node_for_adding)
-
-    def add_edge(
-        self, u_of_edge: Node | int, v_of_edge: Node | int, **attr
-    ) -> None:
-        """Adds an edge to the graph.
-
-        Args:
-            u_of_edge: The source node of the edge. If it is a `Node`, its
-                `node_id` is used as the source. Otherwise, it is assumed to be
-                the node_id of the source.
-            v_of_edge: The destination node of the edge. If it is a `Node`, its
-                `node_id` is used as the destination. Otherwise, it is assumed
-                to be the node_id of the destination.
-            **attr: Additional attributes to be added to the edge.
-
-        Raises:
-            JobShopLibError: If `u_of_edge` or `v_of_edge` are not in the
-                graph.
-        """
-        if isinstance(u_of_edge, Node):
-            u_of_edge = u_of_edge.node_id
-        if isinstance(v_of_edge, Node):
-            v_of_edge = v_of_edge.node_id
-        if u_of_edge not in self.graph or v_of_edge not in self.graph:
-            raise JobShopLibError(
-                "`u_of_edge` and `v_of_edge` must be in the graph."
-            )
-        self.graph.add_edge(u_of_edge, v_of_edge, **attr)
-
-    def remove_node(self, node_id: int) -> None:
-        """Removes a node from the graph and the isolated nodes that result
-        from the removal.
-
-        Args:
-            node_id: The id of the node to remove.
-        """
-        self.graph.remove_node(node_id)
-        self.removed_nodes[node_id] = True
-
-        isolated_nodes = list(nx.isolates(self.graph))
-        for isolated_node in isolated_nodes:
-            self.removed_nodes[isolated_node] = True
-
-        self.graph.remove_nodes_from(isolated_nodes)
-
-    def is_removed(self, node: int | Node) -> bool:
-        """Returns whether the node is removed from the graph.
-
-        Args:
-            node: The node to check. If it is a `Node`, its `node_id` is used
-                as the node to check. Otherwise, it is assumed to be the
-                `node_id` of the node to check.
-        """
-        if isinstance(node, Node):
-            node = node.node_id
-        return self.removed_nodes[node]

job_shop_lib/graphs/node.py

@@ -1,166 +0,0 @@
-"""Home of the `Node` class."""
-
-from job_shop_lib import Operation, JobShopLibError
-from job_shop_lib.graphs.constants import NodeType
-
-
-class Node:
-    """Data structure to represent a node in the `JobShopGraph`.
-
-    A node is hashable by its id. The id is assigned when the node is added to
-    the graph. The id must be unique for each node in the graph, and should be
-    used to identify the node in the networkx graph.
-
-    Depending on the type of the node, it can have different attributes. The
-    following table shows the attributes of each type of node:
-
-    Node Type       | Required Attribute
-    ----------------|---------------------
-    OPERATION       | `operation`
-    MACHINE         | `machine_id`
-    JOB             | `job_id`
-
-    In terms of equality, two nodes are equal if they have the same id.
-    Additionally, one node is equal to an integer if the integer is equal to
-    its id. It is also hashable by its id.
-
-    This allows for using the node as a key in a dictionary, at the same time
-    we can use its id to index that dictionary. Example:
-
-    ```python
-    node = Node(NodeType.SOURCE)
-    node.node_id = 1
-    graph = {node: "some value"}
-    print(graph[node])  # "some value"
-    print(graph[1])  # "some value"
-    ```
-
-    Attributes:
-        node_type:
-            The type of the node. It can be one of the following:
-            - NodeType.OPERATION
-            - NodeType.MACHINE
-            - NodeType.JOB
-            - NodeType.GLOBAL
-            ...
-    """
-
-    __slots__ = "node_type", "_node_id", "_operation", "_machine_id", "_job_id"
-
-    def __init__(
-        self,
-        node_type: NodeType,
-        operation: Operation | None = None,
-        machine_id: int | None = None,
-        job_id: int | None = None,
-    ):
-        """Initializes the node with the given attributes.
-
-        Args:
-            node_type:
-                The type of the node. It can be one of the following:
-                - NodeType.OPERATION
-                - NodeType.MACHINE
-                - NodeType.JOB
-                - NodeType.GLOBAL
-                ...
-            operation:
-                The operation of the node. It should be provided if the
-                `node_type` is NodeType.OPERATION.
-            machine_id:
-                The id of the machine of the node. It should be provided if the
-                node_type is NodeType.MACHINE.
-            job_id:
-                The id of the job of the node. It should be provided if the
-                node_type is NodeType.JOB.
-
-        Raises:
-            JobShopLibError:
-                If the node_type is OPERATION and operation is None.
-            JobShopLibError:
-                If the node_type is MACHINE and machine_id is None.
-            JobShopLibError:
-                If the node_type is JOB and job_id is None.
-        """
-        if node_type == NodeType.OPERATION and operation is None:
-            raise JobShopLibError("Operation node must have an operation.")
-
-        if node_type == NodeType.MACHINE and machine_id is None:
-            raise JobShopLibError("Machine node must have a machine_id.")
-
-        if node_type == NodeType.JOB and job_id is None:
-            raise JobShopLibError("Job node must have a job_id.")
-
-        self.node_type = node_type
-        self._node_id: int | None = None
-
-        self._operation = operation
-        self._machine_id = machine_id
-        self._job_id = job_id
-
-    @property
-    def node_id(self) -> int:
-        """Returns a unique identifier for the node."""
-        if self._node_id is None:
-            raise JobShopLibError("Node has not been assigned an id.")
-        return self._node_id
-
-    @node_id.setter
-    def node_id(self, value: int) -> None:
-        self._node_id = value
-
-    @property
-    def operation(self) -> Operation:
-        """Returns the operation of the node.
-
-        This property is mandatory for nodes of type `OPERATION`.
-        """
-        if self._operation is None:
-            raise JobShopLibError("Node has no operation.")
-        return self._operation
-
-    @property
-    def machine_id(self) -> int:
-        """Returns the `machine_id` of the node.
-
-        This property is mandatory for nodes of type `MACHINE`.
-        """
-        if self._machine_id is None:
-            raise JobShopLibError("Node has no `machine_id`.")
-        return self._machine_id
-
-    @property
-    def job_id(self) -> int:
-        """Returns the `job_id` of the node.
-
-        This property is mandatory for nodes of type `JOB`.
-        """
-        if self._job_id is None:
-            raise JobShopLibError("Node has no `job_id`.")
-        return self._job_id
-
-    def __hash__(self) -> int:
-        return self.node_id
-
-    def __eq__(self, __value: object) -> bool:
-        if isinstance(__value, Node):
-            __value = __value.node_id
-        return self.node_id == __value
-
-    def __repr__(self) -> str:
-        if self.node_type == NodeType.OPERATION:
-            return (
-                f"Node(node_type={self.node_type.name}, id={self._node_id}, "
-                f"operation={self.operation})"
-            )
-        if self.node_type == NodeType.MACHINE:
-            return (
-                f"Node(node_type={self.node_type.name}, id={self._node_id}, "
-                f"machine_id={self._machine_id})"
-            )
-        if self.node_type == NodeType.JOB:
-            return (
-                f"Node(node_type={self.node_type.name}, id={self._node_id}, "
-                f"job_id={self._job_id})"
-            )
-        return f"Node(node_type={self.node_type.name}, id={self._node_id})"

job_shop_lib/operation.py

@@ -1,122 +0,0 @@
-"""Home of the `Operation` class."""
-
-from __future__ import annotations
-
-from job_shop_lib import JobShopLibError
-
-
-class Operation:
-    """Stores machine and duration information for a job operation.
-
-    Note:
-        To increase performance, some solvers such as the CP-SAT solver use
-        only integers to represent the operation's attributes. Should a
-        problem involve operations with non-integer durations, it would be
-        necessary to multiply all durations by a sufficiently large integer so
-        that every duration is an integer.
-
-    Attributes:
-        machines: A list of machine ids that can perform the operation.
-        duration: The time it takes to perform the operation.
-    """
-
-    __slots__ = (
-        "machines",
-        "duration",
-        "_job_id",
-        "_position_in_job",
-        "_operation_id",
-    )
-
-    def __init__(self, machines: int | list[int], duration: int):
-        """Initializes the object with the given machines and duration.
-
-        Args:
-            machines: A list of machine ids that can perform the operation. If
-                only one machine can perform the operation, it can be passed as
-                an integer.
-            duration: The time it takes to perform the operation.
-        """
-        self.machines = [machines] if isinstance(machines, int) else machines
-        self.duration = duration
-
-        # Defined outside the class by the JobShopInstance class:
-        self._job_id: int | None = None
-        self._position_in_job: int | None = None
-        self._operation_id: int | None = None
-
-    @property
-    def machine_id(self) -> int:
-        """Returns the id of the machine associated with the operation.
-
-        Raises:
-            ValueError: If the operation has multiple machines in its list.
-        """
-        if len(self.machines) > 1:
-            raise JobShopLibError("Operation has multiple machines.")
-        return self.machines[0]
-
-    @property
-    def job_id(self) -> int:
-        """Returns the id of the job that the operation belongs to."""
-        if self._job_id is None:
-            raise JobShopLibError("Operation has no job_id.")
-        return self._job_id
-
-    @job_id.setter
-    def job_id(self, value: int) -> None:
-        self._job_id = value
-
-    @property
-    def position_in_job(self) -> int:
-        """Returns the position (starting at zero) of the operation in the
-        job.
-
-        Raises:
-            ValueError: If the operation has no position_in_job.
-        """
-        if self._position_in_job is None:
-            raise JobShopLibError("Operation has no position_in_job.")
-        return self._position_in_job
-
-    @position_in_job.setter
-    def position_in_job(self, value: int) -> None:
-        self._position_in_job = value
-
-    @property
-    def operation_id(self) -> int:
-        """Returns the id of the operation.
-
-        The operation id is unique within a job shop instance and should
-        be set by the JobShopInstance class.
-
-        It starts at 0 and is incremented by 1 for each operation in the
-        instance.
-
-        Raises:
-            ValueError: If the operation has no id.
-        """
-        if self._operation_id is None:
-            raise JobShopLibError("Operation has no id.")
-        return self._operation_id
-
-    @operation_id.setter
-    def operation_id(self, value: int) -> None:
-        self._operation_id = value
-
-    def __hash__(self) -> int:
-        return hash(self.operation_id)
-
-    def __eq__(self, value: object) -> bool:
-        if not isinstance(value, Operation):
-            return False
-        return self.__slots__ == value.__slots__
-
-    def __repr__(self) -> str:
-        machines = (
-            self.machines[0] if len(self.machines) == 1 else self.machines
-        )
-        return (
-            f"O(m={machines}, d={self.duration}, "
-            f"j={self.job_id}, p={self.position_in_job})"
-        )