job-shop-lib 0.5.0__tar.gz → 0.5.1__tar.gz

{job_shop_lib-0.5.0 → job_shop_lib-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: job-shop-lib
-Version: 0.5.0
+Version: 0.5.1
 Summary: An easy-to-use and modular Python library for the Job Shop Scheduling Problem (JSSP)
 License: MIT
 Author: Pabloo22

job_shop_lib-0.5.1/job_shop_lib/generation/__init__.py

@@ -0,0 +1,11 @@
+"""Package for generating job shop instances."""
+
+from job_shop_lib.generation.instance_generator import InstanceGenerator
+from job_shop_lib.generation.general_instance_generator import (
+    GeneralInstanceGenerator,
+)
+
+__all__ = [
+    "InstanceGenerator",
+    "GeneralInstanceGenerator",
+]

job_shop_lib-0.5.1/job_shop_lib/generation/general_instance_generator.py

@@ -0,0 +1,169 @@
+"""Home of the `BasicGenerator` class."""
+
+import random
+
+from job_shop_lib import JobShopInstance, Operation
+from job_shop_lib.generation import InstanceGenerator
+
+
+class GeneralInstanceGenerator(InstanceGenerator):
+    """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.
+        """
+        super().__init__(
+            num_jobs=num_jobs,
+            num_machines=num_machines,
+            duration_range=duration_range,
+            name_suffix=name_suffix,
+            seed=seed,
+            iteration_limit=iteration_limit,
+        )
+        if isinstance(machines_per_operation, int):
+            machines_per_operation = (
+                machines_per_operation,
+                machines_per_operation,
+            )
+        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
+
+        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._next_name())
+
+    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

job_shop_lib-0.5.1/job_shop_lib/generation/instance_generator.py

@@ -0,0 +1,122 @@
+import abc
+
+import random
+from typing import Iterator
+
+from job_shop_lib import JobShopInstance
+
+
+class InstanceGenerator(abc.ABC):
+    """Common interface for all generators.
+
+    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.
+        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),
+        name_suffix: str = "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.
+            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 seed is not None:
+            random.seed(seed)
+
+        self.num_jobs_range = num_jobs
+        self.num_machines_range = num_machines
+        self.duration_range = duration_range
+        self.name_suffix = name_suffix
+
+        self._counter = 0
+        self._current_iteration = 0
+        self._iteration_limit = iteration_limit
+
+    @abc.abstractmethod
+    def generate(self) -> JobShopInstance:
+        """Generates a single job shop instance"""
+
+    def _next_name(self) -> str:
+        self._counter += 1
+        return f"{self.name_suffix}_{self._counter}"
+
+    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
+
+    @property
+    def max_num_jobs(self) -> int:
+        """Returns the maximum number of jobs that can be generated."""
+        return self.num_jobs_range[1]
+
+    @property
+    def min_num_jobs(self) -> int:
+        """Returns the minimum number of jobs that can be generated."""
+        return self.num_jobs_range[0]
+
+    @property
+    def max_num_machines(self) -> int:
+        """Returns the maximum number of machines that can be generated."""
+        return self.num_machines_range[1]
+
+    @property
+    def min_num_machines(self) -> int:
+        """Returns the minimum number of machines that can be generated."""
+        return self.num_machines_range[0]

{job_shop_lib-0.5.0 → job_shop_lib-0.5.1}/job_shop_lib/generators/__init__.py

@@ -1,4 +1,5 @@
-"""Package for generating job shop instances."""
+"""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
 

{job_shop_lib-0.5.0 → job_shop_lib-0.5.1}/job_shop_lib/generators/basic_generator.py

@@ -9,6 +9,9 @@ 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.
 

job_shop_lib-0.5.1/job_shop_lib/generators/transformations.py

@@ -0,0 +1,164 @@
+"""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-0.5.0 → job_shop_lib-0.5.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "job-shop-lib"
-version = "0.5.0"
+version = "0.5.1"
 description = "An easy-to-use and modular Python library for the Job Shop Scheduling Problem (JSSP)"
 authors = ["Pabloo22 <pablete.arino@gmail.com>"]
 license = "MIT"