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

job_shop_lib/generators/basic_generator.py

@@ -1,197 +0,0 @@
-"""Home of the `BasicGenerator` class."""
-
-import random
-from typing import Iterator
-
-from job_shop_lib import JobShopInstance, Operation
-
-
-class BasicGenerator:  # pylint: disable=too-many-instance-attributes
-    """Generates instances for job shop problems.
-
-    This class is designed to be versatile, enabling the creation of various
-    job shop instances without the need for multiple dedicated classes.
-
-    It supports customization of the number of jobs, machines, operation
-    durations, and more.
-
-    The class supports both single instance generation and iteration over
-    multiple instances, controlled by the `iteration_limit` parameter. It
-    implements the iterator protocol, allowing it to be used in a `for` loop.
-
-    Note:
-        When used as an iterator, the generator will produce instances until it
-        reaches the specified `iteration_limit`. If `iteration_limit` is None,
-        it will continue indefinitely.
-
-    Attributes:
-        num_jobs_range:
-            The range of the number of jobs to generate. If a single
-            int is provided, it is used as both the minimum and maximum.
-        duration_range:
-            The range of durations for each operation.
-        num_machines_range:
-            The range of the number of machines available. If a
-            single int is provided, it is used as both the minimum and maximum.
-        machines_per_operation:
-            Specifies how many machines each operation
-            can be assigned to. If a single int is provided, it is used for
-            all operations.
-        allow_less_jobs_than_machines:
-            If True, allows generating instances where the number of jobs is
-            less than the number of machines.
-        allow_recirculation:
-            If True, a job can visit the same machine more than once.
-        name_suffix:
-            A suffix to append to each instance's name for identification.
-        seed:
-            Seed for the random number generator to ensure reproducibility.
-    """
-
-    def __init__(  # pylint: disable=too-many-arguments
-        self,
-        num_jobs: int | tuple[int, int] = (10, 20),
-        num_machines: int | tuple[int, int] = (5, 10),
-        duration_range: tuple[int, int] = (1, 99),
-        allow_less_jobs_than_machines: bool = True,
-        allow_recirculation: bool = False,
-        machines_per_operation: int | tuple[int, int] = 1,
-        name_suffix: str = "classic_generated_instance",
-        seed: int | None = None,
-        iteration_limit: int | None = None,
-    ):
-        """Initializes the instance generator with the given parameters.
-
-        Args:
-            num_jobs:
-                The range of the number of jobs to generate.
-            num_machines:
-                The range of the number of machines available.
-            duration_range:
-                The range of durations for each operation.
-            allow_less_jobs_than_machines:
-                Allows instances with fewer jobs than machines.
-            allow_recirculation:
-                Allows jobs to visit the same machine multiple times.
-            machines_per_operation:
-                Specifies how many machines each operation can be assigned to.
-                If a single int is provided, it is used for all operations.
-            name_suffix:
-                Suffix for instance names.
-            seed:
-                Seed for the random number generator.
-            iteration_limit:
-                Maximum number of instances to generate in iteration mode.
-        """
-        if isinstance(num_jobs, int):
-            num_jobs = (num_jobs, num_jobs)
-
-        if isinstance(num_machines, int):
-            num_machines = (num_machines, num_machines)
-
-        if isinstance(machines_per_operation, int):
-            machines_per_operation = (
-                machines_per_operation,
-                machines_per_operation,
-            )
-
-        self.num_jobs_range = num_jobs
-        self.duration_range = duration_range
-        self.num_machines_range = num_machines
-        self.machines_per_operation = machines_per_operation
-
-        self.allow_less_jobs_than_machines = allow_less_jobs_than_machines
-        self.allow_recirculation = allow_recirculation
-        self.name_suffix = name_suffix
-
-        self._counter = 0
-        self._current_iteration = 0
-        self._iteration_limit = iteration_limit
-
-        if seed is not None:
-            random.seed(seed)
-
-    def generate(self) -> JobShopInstance:
-        """Generates a single job shop instance"""
-        num_jobs = random.randint(*self.num_jobs_range)
-
-        min_num_machines, max_num_machines = self.num_machines_range
-        if not self.allow_less_jobs_than_machines:
-            min_num_machines = min(num_jobs, max_num_machines)
-        num_machines = random.randint(min_num_machines, max_num_machines)
-
-        jobs = []
-        available_machines = list(range(num_machines))
-        for _ in range(num_jobs):
-            job = []
-            for _ in range(num_machines):
-                operation = self.create_random_operation(available_machines)
-                job.append(operation)
-            jobs.append(job)
-            available_machines = list(range(num_machines))
-
-        return JobShopInstance(jobs=jobs, name=self._get_name())
-
-    def __iter__(self) -> Iterator[JobShopInstance]:
-        self._current_iteration = 0
-        return self
-
-    def __next__(self) -> JobShopInstance:
-        if (
-            self._iteration_limit is not None
-            and self._current_iteration >= self._iteration_limit
-        ):
-            raise StopIteration
-        self._current_iteration += 1
-        return self.generate()
-
-    def __len__(self) -> int:
-        if self._iteration_limit is None:
-            raise ValueError("Iteration limit is not set.")
-        return self._iteration_limit
-
-    def create_random_operation(
-        self, available_machines: list[int] | None = None
-    ) -> Operation:
-        """Creates a random operation with the given available machines.
-
-        Args:
-            available_machines:
-                A list of available machine_ids to choose from.
-                If None, all machines are available.
-        """
-        duration = random.randint(*self.duration_range)
-
-        if self.machines_per_operation[1] > 1:
-            machines = self._choose_multiple_machines()
-            return Operation(machines=machines, duration=duration)
-
-        machine_id = self._choose_one_machine(available_machines)
-        return Operation(machines=machine_id, duration=duration)
-
-    def _choose_multiple_machines(self) -> list[int]:
-        num_machines = random.randint(*self.machines_per_operation)
-        available_machines = list(range(num_machines))
-        machines = []
-        for _ in range(num_machines):
-            machine = random.choice(available_machines)
-            machines.append(machine)
-            available_machines.remove(machine)
-        return machines
-
-    def _choose_one_machine(
-        self, available_machines: list[int] | None = None
-    ) -> int:
-        if available_machines is None:
-            _, max_num_machines = self.num_machines_range
-            available_machines = list(range(max_num_machines))
-
-        machine_id = random.choice(available_machines)
-        if not self.allow_recirculation:
-            available_machines.remove(machine_id)
-
-        return machine_id
-
-    def _get_name(self) -> str:
-        self._counter += 1
-        return f"{self.name_suffix}_{self._counter}"

job_shop_lib/graphs/constants.py

@@ -1,21 +0,0 @@
-"""Constants for the graph module."""
-
-import enum
-
-
-class EdgeType(enum.Enum):
-    """Enumeration of edge types."""
-
-    CONJUNCTIVE = 0
-    DISJUNCTIVE = 1
-
-
-class NodeType(enum.Enum):
-    """Enumeration of node types."""
-
-    OPERATION = enum.auto()
-    MACHINE = enum.auto()
-    JOB = enum.auto()
-    GLOBAL = enum.auto()
-    SOURCE = enum.auto()
-    SINK = enum.auto()

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})"