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

job_shop_lib/dispatching/feature_observers/is_completed_observer.py

@@ -1,98 +0,0 @@
-"""Home of the `IsCompletedObserver` class."""
-
-from typing import Iterable
-
-import numpy as np
-
-from job_shop_lib import ScheduledOperation
-from job_shop_lib.dispatching import Dispatcher
-from job_shop_lib.dispatching.feature_observers import (
-    FeatureObserver,
-    FeatureType,
-    RemainingOperationsObserver,
-)
-
-
-class IsCompletedObserver(FeatureObserver):
-    """Observer that adds a binary feature indicating whether each operation,
-    machine, or job has been completed."""
-
-    def __init__(
-        self,
-        dispatcher: Dispatcher,
-        feature_types: list[FeatureType] | FeatureType | None = None,
-    ):
-        feature_types = self.get_feature_types_list(feature_types)
-        self.remaining_ops_per_machine = np.zeros(
-            (dispatcher.instance.num_machines, 1), dtype=int
-        )
-        self.remaining_ops_per_job = np.zeros(
-            (dispatcher.instance.num_jobs, 1), dtype=int
-        )
-        super().__init__(dispatcher, feature_types, feature_size=1)
-
-    def initialize_features(self):
-        self._initialize_remaining_operations()
-
-    def update(self, scheduled_operation: ScheduledOperation):
-        if FeatureType.OPERATIONS in self.features:
-            # operation_id = scheduled_operation.operation.operation_id
-            # self.features[FeatureType.OPERATIONS][operation_id, 0] = 1
-            completed_operations = [
-                op.operation_id
-                for op in self.dispatcher.completed_operations()
-            ]
-            self.features[FeatureType.OPERATIONS][completed_operations, 0] = 1
-        if FeatureType.MACHINES in self.features:
-            machine_id = scheduled_operation.machine_id
-            self.remaining_ops_per_machine[machine_id, 0] -= 1
-            is_completed = self.remaining_ops_per_machine[machine_id, 0] == 0
-            self.features[FeatureType.MACHINES][machine_id, 0] = is_completed
-        if FeatureType.JOBS in self.features:
-            job_id = scheduled_operation.job_id
-            self.remaining_ops_per_job[job_id, 0] -= 1
-            is_completed = self.remaining_ops_per_job[job_id, 0] == 0
-            self.features[FeatureType.JOBS][job_id, 0] = is_completed
-
-    def _initialize_remaining_operations(self):
-        remaining_ops_observer = self._get_remaining_operations_observer(
-            self.dispatcher, self.features
-        )
-        if remaining_ops_observer is not None:
-            if FeatureType.JOBS in self.features:
-                self.remaining_ops_per_job = remaining_ops_observer.features[
-                    FeatureType.JOBS
-                ].copy()
-            if FeatureType.MACHINES in self.features:
-                self.remaining_ops_per_machine = (
-                    remaining_ops_observer.features[
-                        FeatureType.MACHINES
-                    ].copy()
-                )
-            return
-
-        # If there is no remaining operations observer, we need to
-        # compute the remaining operations ourselves.
-        # We iterate over all operations using scheduled_operations
-        # instead of uncompleted_operations, because in this case
-        # they will output the same operations, and the former is slightly
-        # more efficient.
-        for operation in self.dispatcher.unscheduled_operations():
-            if FeatureType.JOBS in self.features:
-                self.remaining_ops_per_job[operation.job_id, 0] += 1
-            if FeatureType.MACHINES in self.features:
-                self.remaining_ops_per_machine[operation.machine_id, 0] += 1
-
-    def _get_remaining_operations_observer(
-        self, dispatcher: Dispatcher, feature_types: Iterable[FeatureType]
-    ) -> RemainingOperationsObserver | None:
-        for observer in dispatcher.subscribers:
-            if not isinstance(observer, RemainingOperationsObserver):
-                continue
-            has_same_features = all(
-                feature_type in observer.features
-                for feature_type in feature_types
-            )
-            if has_same_features:
-                return observer
-        return None

job_shop_lib/dispatching/feature_observers/is_ready_observer.py

@@ -1,40 +0,0 @@
-"""Home of the `IsReadyObserver` class."""
-
-from job_shop_lib.dispatching import Dispatcher
-from job_shop_lib.dispatching.feature_observers import (
-    FeatureObserver,
-    FeatureType,
-)
-
-
-class IsReadyObserver(FeatureObserver):
-    """Feature creator that adds a binary feature indicating if the operation
-    is ready to be dispatched."""
-
-    def __init__(
-        self,
-        dispatcher: Dispatcher,
-        feature_types: list[FeatureType] | FeatureType | None = None,
-        subscribe: bool = True,
-    ):
-        super().__init__(
-            dispatcher, feature_types, feature_size=1, subscribe=subscribe
-        )
-
-    def initialize_features(self):
-        self.set_features_to_zero()
-        for feature_type, feature in self.features.items():
-            node_ids = self._get_ready_nodes(feature_type)
-            feature[node_ids, 0] = 1.0
-
-    def _get_ready_nodes(self, feature_type: FeatureType) -> list[int]:
-        mapping = {
-            FeatureType.OPERATIONS: self._get_ready_operation_nodes,
-            FeatureType.MACHINES: self.dispatcher.available_machines,
-            FeatureType.JOBS: self.dispatcher.available_jobs,
-        }
-        return mapping[feature_type]()
-
-    def _get_ready_operation_nodes(self) -> list[int]:
-        available_operations = self.dispatcher.available_operations()
-        return [operation.operation_id for operation in available_operations]

job_shop_lib/generators/__init__.py

@@ -1,8 +0,0 @@
-"""DEPRECATED: Use `job_shop_lib.generation` instead. It will be removed in
-version 1.0.0."""
-
-from job_shop_lib.generators.basic_generator import BasicGenerator
-
-__all__ = [
-    "BasicGenerator",
-]

job_shop_lib/generators/basic_generator.py

@@ -1,200 +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.
-
-    DEPRECATED: Class moved to `job_shop_lib.generation` and renamed to
-    `GeneralInstanceGenerator`. This class will be removed in version 1.0.0.
-
-    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/generators/transformations.py

@@ -1,164 +0,0 @@
-"""Classes for generating transformed JobShopInstance objects."""
-
-import abc
-import copy
-import random
-
-from job_shop_lib import JobShopInstance, Operation
-
-
-class Transformation(abc.ABC):
-    """Base class for transformations applied to JobShopInstance objects."""
-
-    def __init__(self, suffix: str = ""):
-        self.suffix = suffix
-        self.counter = 0
-
-    @abc.abstractmethod
-    def apply(self, instance: JobShopInstance) -> JobShopInstance:
-        """Applies the transformation to a given JobShopInstance.
-
-        Args:
-            instance: The JobShopInstance to transform.
-
-        Returns:
-            A new JobShopInstance with the transformation applied.
-        """
-
-    def __call__(self, instance: JobShopInstance) -> JobShopInstance:
-        instance = self.apply(instance)
-        suffix = f"{self.suffix}_id={self.counter}"
-        instance.name += suffix
-        self.counter += 1
-        return instance
-
-
-# pylint: disable=too-few-public-methods
-class RemoveMachines(Transformation):
-    """Removes operations associated with randomly selected machines until
-    there are exactly num_machines machines left."""
-
-    def __init__(self, num_machines: int, suffix: str | None = None):
-        if suffix is None:
-            suffix = f"_machines={num_machines}"
-        super().__init__(suffix=suffix)
-        self.num_machines = num_machines
-
-    def apply(self, instance: JobShopInstance) -> JobShopInstance:
-        if instance.num_machines <= self.num_machines:
-            return instance  # No need to remove machines
-
-        # Select machine indices to keep
-        machines_to_keep = set(
-            random.sample(range(instance.num_machines), self.num_machines)
-        )
-
-        # Re-index machines
-        machine_reindex_map = {
-            old_id: new_id
-            for new_id, old_id in enumerate(sorted(machines_to_keep))
-        }
-
-        new_jobs = []
-        for job in instance.jobs:
-            # Keep operations whose machine_id is in machines_to_keep and
-            # re-index them
-            new_jobs.append(
-                [
-                    Operation(machine_reindex_map[op.machine_id], op.duration)
-                    for op in job
-                    if op.machine_id in machines_to_keep
-                ]
-            )
-
-        return JobShopInstance(new_jobs, instance.name)
-
-
-# pylint: disable=too-few-public-methods
-class AddDurationNoise(Transformation):
-    """Adds uniform integer noise to operation durations."""
-
-    def __init__(
-        self,
-        min_duration: int = 1,
-        max_duration: int = 100,
-        noise_level: int = 10,
-        suffix: str | None = None,
-    ):
-        if suffix is None:
-            suffix = f"_noise={noise_level}"
-        super().__init__(suffix=suffix)
-        self.min_duration = min_duration
-        self.max_duration = max_duration
-        self.noise_level = noise_level
-
-    def apply(self, instance: JobShopInstance) -> JobShopInstance:
-        new_jobs = []
-        for job in instance.jobs:
-            new_job = []
-            for op in job:
-                noise = random.randint(-self.noise_level, self.noise_level)
-                new_duration = max(
-                    self.min_duration,
-                    min(self.max_duration, op.duration + noise),
-                )
-
-                new_job.append(Operation(op.machine_id, new_duration))
-            new_jobs.append(new_job)
-
-        return JobShopInstance(new_jobs, instance.name)
-
-
-class RemoveJobs(Transformation):
-    """Removes jobs randomly until the number of jobs is within a specified
-    range."""
-
-    def __init__(
-        self,
-        min_jobs: int,
-        max_jobs: int,
-        target_jobs: int | None = None,
-        suffix: str | None = None,
-    ):
-        """
-        Args:
-            min_jobs: The minimum number of jobs to remain in the instance.
-            max_jobs: The maximum number of jobs to remain in the instance.
-            target_jobs: If specified, the number of jobs to remain in the
-                instance. Overrides min_jobs and max_jobs.
-        """
-        if suffix is None:
-            suffix = f"_jobs={min_jobs}-{max_jobs}"
-        super().__init__(suffix=suffix)
-        self.min_jobs = min_jobs
-        self.max_jobs = max_jobs
-        self.target_jobs = target_jobs
-
-    def apply(self, instance: JobShopInstance) -> JobShopInstance:
-        if self.target_jobs is None:
-            target_jobs = random.randint(self.min_jobs, self.max_jobs)
-        else:
-            target_jobs = self.target_jobs
-        new_jobs = copy.deepcopy(instance.jobs)
-
-        while len(new_jobs) > target_jobs:
-            new_jobs.pop(random.randint(0, len(new_jobs) - 1))
-
-        return JobShopInstance(new_jobs, instance.name)
-
-    @staticmethod
-    def remove_job(
-        instance: JobShopInstance, job_index: int
-    ) -> JobShopInstance:
-        """Removes a specific job from the instance.
-
-        Args:
-            instance: The JobShopInstance from which to remove the job.
-            job_index: The index of the job to remove.
-
-        Returns:
-            A new JobShopInstance with the specified job removed.
-        """
-        new_jobs = copy.deepcopy(instance.jobs)
-        new_jobs.pop(job_index)
-        return JobShopInstance(new_jobs, instance.name)

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