job-shop-lib 1.3.0__py3-none-any.whl → 1.6.0__py3-none-any.whl

job_shop_lib/metaheuristics/_neighbor_generators.py

@@ -0,0 +1,182 @@
+from collections.abc import Callable
+import random
+
+from job_shop_lib import Schedule, ScheduledOperation
+from job_shop_lib.exceptions import ValidationError
+
+
+NeighborGenerator = Callable[[Schedule, random.Random], Schedule]
+
+_MAX_ATTEMPTS = 1000
+
+
+def _swap_with_index_picker(
+    schedule: Schedule,
+    random_generator: random.Random | None,
+    index_picker: Callable[[list, random.Random], tuple[int, int]],
+) -> Schedule:
+    """Generates a neighbor schedule by swapping two positions chosen by a
+    strategy.
+
+    This private helper applies a swap on a randomly selected machine whose
+    sequence has at least two operations. The actual indices to swap are
+    chosen by the provided picker function. It attempts up to a fixed number
+    of times to produce a valid neighbor. If all attempts fail, it returns
+    the original schedule unchanged.
+
+    Args:
+        schedule:
+            Current schedule to perturb.
+
+        random_generator:
+            Source of randomness. If ``None``, a new generator is created.
+
+        index_picker:
+            Function that receives a machine sequence and a random generator
+            and returns two indices to swap.
+
+    Returns:
+        A valid neighbor schedule if a feasible swap is found, otherwise the
+        original schedule.
+    """
+    if random_generator is None:
+        random_generator = random.Random()
+    job_sequences = schedule.job_sequences()
+    valid_machines = [i for i, seq in enumerate(job_sequences) if len(seq) > 1]
+    if not valid_machines:
+        return schedule
+
+    for _ in range(_MAX_ATTEMPTS):
+        machine_id = random_generator.choice(valid_machines)
+        sequence = job_sequences[machine_id]
+        idx1, idx2 = index_picker(sequence, random_generator)
+        sequence[idx1], sequence[idx2] = sequence[idx2], sequence[idx1]
+        try:
+            return Schedule.from_job_sequences(
+                schedule.instance, job_sequences
+            )
+        except ValidationError:
+            pass
+    return schedule
+
+
+def swap_adjacent_operations(
+    schedule: Schedule, random_generator: random.Random | None = None
+) -> Schedule:
+    """Generates a neighbor schedule by swapping two adjacent operations.
+
+    Selects a machine at random with at least two operations and swaps a pair
+    of adjacent operations in its sequence. Internally tries several times to
+    produce a valid neighbor; if none is found, the original schedule is
+    returned.
+
+    Args:
+        schedule:
+            Current schedule to perturb.
+
+        random_generator:
+            Source of randomness. If ``None``, a new generator is created.
+
+    Returns:
+        A valid neighbor schedule with one adjacent swap applied, or the
+        original schedule if no valid swap is found.
+    """
+
+    def adjacent_picker(seq: list, rng: random.Random) -> tuple[int, int]:
+        idx = rng.randint(0, len(seq) - 2)
+        return idx, idx + 1
+
+    return _swap_with_index_picker(schedule, random_generator, adjacent_picker)
+
+
+def swap_random_operations(
+    schedule: Schedule, random_generator: random.Random | None = None
+) -> Schedule:
+    """Generates a neighbor schedule by swapping two random operations.
+
+    Selects a machine at random with at least two operations and swaps two
+    randomly chosen positions in its sequence. Internally tries several times
+    to produce a valid neighbor; if none is found, the original schedule is
+    returned.
+
+    Args:
+        schedule:
+            Current schedule to perturb.
+
+        random_generator:
+            Source of randomness. If ``None``, a new generator is created.
+
+    Returns:
+        A valid neighbor schedule with one random swap applied, or the
+        original schedule if no valid swap is found.
+    """
+
+    def random_picker(seq: list, rng: random.Random) -> tuple[int, int]:
+        idx1, idx2 = rng.sample(range(len(seq)), 2)
+        return idx1, idx2
+
+    return _swap_with_index_picker(schedule, random_generator, random_picker)
+
+
+def swap_in_critical_path(
+    schedule: Schedule, random_generator: random.Random | None = None
+) -> Schedule:
+    """Generates a neighbor by targeting swaps on the critical path.
+
+    This operator focuses on pairs of consecutive scheduled operations along
+    the current critical path that share the same machine. Swapping such
+    operations directly perturbs the longest-duration chain of precedence
+    and resource constraints that determines the makespan.
+
+    Why target the critical path:
+
+    - The makespan is the length of the critical path; operations not on it
+      typically have slack, so reordering them often does not improve the
+      objective. By contrast, modifying machine order on the critical path
+      can shorten the longest path or unlock constraints that reduce
+      blocking and idle times.
+    - Swapping consecutive critical operations on the same machine always
+      results in a feasible schedule.
+
+    Behavior:
+
+    - Identifies all consecutive pairs on the critical path that run on the
+      same machine and swaps one of them at random.
+    - If no such pairs exist, it falls back to a standard adjacent swap.
+
+    Args:
+        schedule:
+            Current schedule to perturb.
+
+        random_generator:
+            Source of randomness. If ``None``, a new generator is created.
+
+    Returns:
+        A valid neighbor schedule that prioritizes swaps on the critical
+        path, or a neighbor produced by an adjacent swap fallback when none
+        applies.
+    """
+    if random_generator is None:
+        random_generator = random.Random()
+
+    critical_path = schedule.critical_path()
+    possible_swaps: list[tuple[ScheduledOperation, ScheduledOperation]] = []
+    for i, current_scheduled_op in enumerate(critical_path[:-1]):
+        next_scheduled_op = critical_path[i + 1]
+        if current_scheduled_op.machine_id == next_scheduled_op.machine_id:
+            possible_swaps.append((current_scheduled_op, next_scheduled_op))
+
+    if not possible_swaps:
+        return swap_adjacent_operations(schedule, random_generator)
+
+    op1, op2 = random_generator.choice(possible_swaps)
+    job_sequences = schedule.job_sequences()
+    machine_id = op1.machine_id
+    idx1 = job_sequences[machine_id].index(op1.operation.job_id)
+    idx2 = job_sequences[machine_id].index(op2.operation.job_id)
+
+    job_sequences[machine_id][idx1], job_sequences[machine_id][idx2] = (
+        job_sequences[machine_id][idx2],
+        job_sequences[machine_id][idx1],
+    )
+    return Schedule.from_job_sequences(schedule.instance, job_sequences)

job_shop_lib/metaheuristics/_objective_functions.py

@@ -0,0 +1,73 @@
+from collections.abc import Callable
+from job_shop_lib import Schedule
+
+
+ObjectiveFunction = Callable[[Schedule], float]
+
+
+def get_makespan_with_penalties_objective(
+    deadline_penalty_factor: float = 1_000_000,
+    due_date_penalty_factor: float = 100,
+) -> ObjectiveFunction:
+    """Builds an objective function that returns the makespan plus penalties.
+
+    This factory returns a callable that evaluates a Schedule as the sum of
+    its makespan and penalties for violating operation-level deadlines and due
+    dates.
+
+    Penalties are applied per scheduled operation that finishes after its
+    corresponding attribute value:
+
+    - Deadline violation: adds ``deadline_penalty_factor`` once per violating
+      operation (hard constraint surrogate).
+    - Due date violation: adds ``due_date_penalty_factor`` once per violating
+      operation (soft constraint surrogate).
+
+    Args:
+        deadline_penalty_factor:
+            Cost added for each operation that
+            finishes after its deadline. Defaults to 1_000_000.
+        due_date_penalty_factor:
+            Cost added for each operation that
+            finishes after its due date. Defaults to 100.
+
+    Returns:
+        A function ``f(schedule) -> float`` that
+        computes ``schedule.makespan() + penalty``.
+
+    Notes:
+        - Deadlines and due dates are taken from each operation. If an
+          operation does not define the attribute (``None``), no penalty is
+          applied for that attribute.
+        - If the instance has neither deadlines nor due dates, the objective is
+          simply the makespan.
+    """
+
+    def objective(schedule: Schedule) -> float:
+        makespan = schedule.makespan()
+        instance = schedule.instance
+
+        # Fast path: no constraint attributes present in the instance
+        if not instance.has_deadlines and not instance.has_due_dates:
+            return makespan
+
+        penalty = 0.0
+        for machine_schedule in schedule.schedule:
+            for scheduled_op in machine_schedule:
+                op = scheduled_op.operation
+                # Deadline (hard) penalty
+                if (
+                    op.deadline is not None
+                    and scheduled_op.end_time > op.deadline
+                ):
+                    penalty += deadline_penalty_factor
+                # Due date (soft) penalty
+                if (
+                    op.due_date is not None
+                    and scheduled_op.end_time > op.due_date
+                ):
+                    penalty += due_date_penalty_factor
+
+        return makespan + penalty
+
+    return objective

job_shop_lib/metaheuristics/_simulated_annealing_solver.py

@@ -0,0 +1,163 @@
+from job_shop_lib import BaseSolver, JobShopInstance, Schedule
+from job_shop_lib.metaheuristics import JobShopAnnealer
+from job_shop_lib.dispatching.rules import DispatchingRuleSolver
+from job_shop_lib.metaheuristics import (
+    NeighborGenerator,
+    swap_in_critical_path,
+    ObjectiveFunction,
+)
+
+
+class SimulatedAnnealingSolver(BaseSolver):
+    """Wraps the :class:`JobShopAnnealer` to follow the
+    :class`~job_shop_lib.BaseSolver` interface.
+
+    .. seealso::
+        See the documentation of the :class:`JobShopAnnealer` class for more
+        details on the annealing process.
+
+    Attributes:
+        initial_temperature:
+            Initial temperature for the annealing process. It controls the
+            probability of accepting worse solutions. That sets the metropolis
+            criterion. Corresponds to the `tmax` parameter in the annealer.
+        ending_temperature:
+            Ending temperature for the annealing process. It controls when to
+            stop accepting worse solutions. Corresponds to the `tmin` parameter
+            in the annealer.
+        steps:
+            Number of steps to perform in the annealing process. This is the
+            number of iterations the algorithm will run.
+        updates:
+            The number of progress updates to print during the annealing
+            process. Set to 0 to disable updates.
+        seed:
+            Random seed for reproducibility. If ``None``, random behavior will
+            be non-deterministic.
+
+    Args:
+        initial_temperature:
+            Initial temperature for the annealing process. It controls the
+            probability of accepting worse solutions. That sets the metropolis
+            criterion. Corresponds to the `tmax` parameter in the annealer.
+        ending_temperature:
+            Ending temperature for the annealing process. It controls when to
+            stop accepting worse solutions. Corresponds to the `tmin` parameter
+            in the annealer.
+        steps:
+            Number of steps to perform in the annealing process. This is the
+            number of iterations the algorithm will run.
+        updates:
+            The number of progress updates to print during the annealing
+            process. Set to 0 to disable updates.
+        seed:
+            Random seed for reproducibility. If ``None``, random behavior will
+            be non-deterministic.
+    """
+
+    def __init__(
+        self,
+        *,
+        initial_temperature: float = 25000,
+        ending_temperature: float = 2.5,
+        steps: int = 50_000,
+        updates: int = 100,
+        objective_function: ObjectiveFunction | None = None,
+        seed: int | None = None,
+        neighbor_generator: NeighborGenerator = swap_in_critical_path,
+    ):
+        self.initial_temperature = initial_temperature
+        self.ending_temperature = ending_temperature
+        self.steps = steps
+        self.updates = updates
+        self.objective_function = objective_function
+        self.seed = seed
+        self.neighbor_generator = neighbor_generator
+        self.annealer_: JobShopAnnealer | None = None
+
+    def setup_annealer(
+        self, instance: JobShopInstance, initial_state: Schedule | None = None
+    ) -> None:
+        """Initializes the annealer with the given instance and initial state.
+
+        Args:
+            instance:
+                The job shop instance to solve.
+            initial_state:
+                Initial state of the schedule as a list of lists, where each
+                sublist represents the operations of a job.
+        """
+        if initial_state is None:
+            initial_state = self._generate_initial_state(instance)
+
+        annealer = JobShopAnnealer(
+            instance,
+            initial_state,
+            objective_function=self.objective_function,
+            seed=self.seed,
+            neighbor_generator=self.neighbor_generator,
+        )
+        best_hparams = {
+            "tmax": self.initial_temperature,
+            "tmin": self.ending_temperature,
+            "steps": self.steps,
+            "updates": self.updates,
+        }
+        annealer.set_schedule(best_hparams)
+        self.annealer_ = annealer
+
+    def solve(
+        self,
+        instance: JobShopInstance,
+        initial_state: Schedule | None = None,
+    ) -> Schedule:
+        """Solves the given Job Shop Scheduling problem using
+        simulated annealing.
+
+        Args:
+            instance:
+                The job shop problem instance to solve.
+            initial_state:
+                Initial job sequences for each machine. A job sequence is a
+                list of job ids. Each list of job ids represents the order of
+                operations on the machine. The machine that the list
+                corresponds to is determined by the index of the list. If
+                ``None``, the solver will generate an initial state using the
+                :class:`DispatchingRuleSolver`.
+
+        Returns:
+            The best schedule found.
+
+        """
+        self.setup_annealer(instance, initial_state)
+        # For type checking purposes, we assert that the annealer is set up.
+        assert (
+            self.annealer_ is not None
+        ), "There was a problem setting up the annealer."
+        try:
+            best_state, _ = self.annealer_.anneal()
+        except KeyboardInterrupt:
+            # If the annealing process is interrupted, we return the best state
+            # found so far.
+            best_state = self.annealer_.best_state
+        return best_state
+
+    @staticmethod
+    def _generate_initial_state(instance: JobShopInstance) -> Schedule:
+        """Uses the
+        :class:`~job_shop_lib.dispatching.rules.DispatchingRuleSolver` to
+        generate an initial state for the annealer.
+
+        .. note::
+            The first solution might be unfeasible if the job shop instance
+            has deadlines.
+
+        Args:
+            instance (JobShopInstance): The job shop problem instance.
+
+        Returns:
+            An initial schedule generated by the dispatching rule solver.
+        """
+        solver = DispatchingRuleSolver()
+        schedule = solver.solve(instance)
+        return schedule

{job_shop_lib-1.3.0.dist-info → job_shop_lib-1.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: job-shop-lib
-Version: 1.3.0
+Version: 1.6.0
 Summary: An easy-to-use and modular Python library for the Job Shop Scheduling Problem (JSSP)
 License: MIT
 Author: Pabloo22
@@ -21,6 +21,7 @@ Requires-Dist: ortools (>=9.9,<10.0) ; sys_platform != "darwin"
 Requires-Dist: ortools (>=9.9,<9.13) ; sys_platform == "darwin"
 Requires-Dist: pyarrow (>=15,<21)
 Requires-Dist: pygraphviz (>=1.12,<2.0) ; extra == "pygraphviz"
+Requires-Dist: simanneal (>=0.5.0,<0.6.0)
 Description-Content-Type: text/markdown
 
 <div align="center">
@@ -42,49 +43,34 @@ JobShopLib is a Python package for creating, solving, and visualizing job shop s
 
 It follows a modular design, allowing users to easily extend the library with new solvers, dispatching rules, visualization functions, etc.
 
-There is a [documentation page](https://job-shop-lib.readthedocs.io/en/stable/) for versions 1.0.0a3 and onward. See the [latest pull requests](https://github.com/Pabloo22/job_shop_lib/pulls?q=is%3Apr+is%3Aclosed) for the latest changes.
+We support multiple solvers, including:
+- **Constraint Programming**: Based on OR-Tools' CP-SAT solver. It supports **release dates, deadlines, and due dates.** See the ["Solving the Problem" tutorial](https://github.com/Pabloo22/job_shop_lib/blob/main/docs/source/tutorial/02-Solving-the-Problem.ipynb) for an example.
+- **Dispatching Rules**: A set of predefined rules and the ability to create custom ones. They support arbitrary **setup times, machine breakdowns, release dates, deadlines, and due dates**. See the [following example](https://github.com/Pabloo22/job_shop_lib/blob/main/docs/source/examples/03-Dispatching-Rules.ipynb). You can also create videos or GIFs of the scheduling process. For creating GIFs or videos, see the [Save Gif example](https://github.com/Pabloo22/job_shop_lib/blob/main/docs/source/examples/04-Save-Gif.ipynb).
+- **Metaheuristics**: Currently, we have a **simulated annealing** implementation that supports **release dates, deadlines, and due dates**. We also support arbitrary neighborhood search strategies, including swapping operations in the critical path as described in the paper "Job Shop Scheduling by Simulated Annealing" by van Laarhoven et al. (1992); and energy functions. See our [simulated annealing tutorial](https://github.com/Pabloo22/job_shop_lib/blob/main/docs/source/tutorial/03-Simulated-Annealing.ipynb).
+- **Reinforcement Learning**: Two Gymnasium environments for solving the problem with **graph neural networks** (GNNs) or any other method. The environments support **setup times, release dates, deadlines, and due dates.** We're currently building a tutorial on how to use them.
 
-See [`gnn_scheduler`](https://github.com/Pabloo22/gnn_scheduler/blob/main/gnn_scheduler/) for an example implementation of a graph neural network-based dispatcher trained with [PyTorch Geometric](https://pyg.org/).
-
-See [this](https://colab.research.google.com/drive/1XV_Rvq1F2ns6DFG8uNj66q_rcowwTZ4H?usp=sharing) Google Colab notebook for a quick start guide! More advanced examples can be found [here](https://job-shop-lib.readthedocs.io/en/stable/examples.html).
+We also provide useful utilities, data structures, and visualization functions:
+- **Intuitive Data Structures**: Easily create, manage, and manipulate job shop instances and solutions with user-friendly data structures. See [Getting Started](https://github.com/Pabloo22/job_shop_lib/blob/main/docs/source/tutorial/00-Getting-Started.ipynb) and [How Solutions are Represented](https://github.com/Pabloo22/job_shop_lib/blob/main/docs/source/tutorial/01-How-Solutions-are-Represented.ipynb).
+- **Benchmark Instances**: Load well-known benchmark instances directly from the library without manual downloading. See [Load Benchmark Instances](https://github.com/Pabloo22/job_shop_lib/blob/main/docs/source/examples/05-Load-Benchmark-Instances.ipynb).
+- **Random Instance Generation**: Create random instances with customizable sizes and properties. See [`generation`](https://job-shop-lib.readthedocs.io/en/stable/api/job_shop_lib.generation.html#module-job_shop_lib.generation) module.
+- **Gantt Charts**: Visualize final schedules and how they are created iteratively by dispatching rule solvers or sequences of scheduling decisions with GIFs or videos.
+- **Graph Representations**: Represent and visualize instances as disjunctive graphs or agent-task graphs (introduced in the ScheduleNet paper). Build your own custom graphs with the `JobShopGraph` class. See the [Disjunctive Graphs](https://github.com/Pabloo22/job_shop_lib/blob/main/docs/source/tutorial/04-Disjunctive-Graphs.ipynb) and [Resource Task Graphs](https://job-shop-lib.readthedocs.io/en/stable/examples/07-Resource-Task-Graph.html) examples.
 
 ## Installation :package:
 
 <!-- start installation -->
 
-JobShopLib is distributed on [PyPI](https://pypi.org/project/job-shop-lib/). You can install the latest stable version using `pip`:
-
 ```bash
 pip install job-shop-lib
 ```
 
-<!-- end installation -->
-
-<!-- key features -->
-
-## Key Features :star:
-
-- **Data Structures**: Easily create, manage, and manipulate job shop instances and solutions with user-friendly data structures. See [Getting Started](https://github.com/Pabloo22/job_shop_lib/blob/main/docs/source/tutorial/00-Getting-Started.ipynb) and [How Solutions are Represented](https://github.com/Pabloo22/job_shop_lib/blob/main/docs/source/tutorial/01-How-Solutions-are-Represented.ipynb).
-
-- **Benchmark Instances**: Load well-known benchmark instances directly from the library without manual downloading. See [Load Benchmark Instances](https://github.com/Pabloo22/job_shop_lib/blob/main/docs/source/examples/05-Load-Benchmark-Instances.ipynb).
-
-- **Random Instance Generation**: Create random instances with customizable sizes and properties. See [`generation`](job_shop_lib/generation) package.
-
-- **Multiple Solvers**:
-  - **Constraint Programming Solver**: OR-Tools' CP-SAT solver. See [Solving the Problem](https://github.com/Pabloo22/job_shop_lib/blob/main/docs/source/tutorial/02-Solving-the-Problem.ipynb).
-
-  - **Dispatching Rule Solvers**: Use any of the available dispatching rules or create custom ones. See [Dispatching Rules](https://github.com/Pabloo22/job_shop_lib/blob/main/docs/source/examples/03-Dispatching-Rules.ipynb).
-
-- **Gantt Charts**: Visualize final schedules and how are they created iteratively by dispatching rule solvers or sequences of scheduling decisions with GIFs or videos. See [Save Gif](https://github.com/Pabloo22/job_shop_lib/blob/main/docs/source/examples/06-Save-Gif.ipynb).
-
-- **Graph Representations**:
-  - **Disjunctive Graphs**: Represent and visualize instances as disjunctive graphs. See [Disjunctive Graph](https://github.com/Pabloo22/job_shop_lib/blob/main/docs/source/examples/04-Disjunctive-Graph.ipynb).
-  - **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.
+or 
 
-- **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).
+```bash
+poetry add job-shop-lib
+```
 
-<!-- end key features -->
+<!-- end installation -->
 
 ## Publication :scroll:
 
@@ -219,6 +205,7 @@ A dispatching rule is a heuristic guideline used to prioritize and sequence jobs
 ```python
 class DispatchingRule(str, Enum):
     SHORTEST_PROCESSING_TIME = "shortest_processing_time"
+    LARGEST_PROCESSING_TIME = "largest_processing_time"
     FIRST_COME_FIRST_SERVED = "first_come_first_served"
     MOST_WORK_REMAINING = "most_work_remaining"
     MOST_OPERATION_REMAINING = "most_operation_remaining"
@@ -432,6 +419,8 @@ This project is licensed under the MIT License - see the [LICENSE](LICENSE) file
 
 ## References :books:
 
+ - Peter J. M. van Laarhoven, Emile H. L. Aarts, Jan Karel Lenstra, (1992) Job Shop Scheduling by Simulated Annealing. Operations Research 40(1):113-125.
+
  - J. Adams, E. Balas, and D. Zawack, "The shifting bottleneck procedure
      for job shop scheduling," Management Science, vol. 34, no. 3,
      pp. 391–401, 1988.

{job_shop_lib-1.3.0.dist-info → job_shop_lib-1.6.0.dist-info}/RECORD

@@ -1,26 +1,27 @@
-job_shop_lib/__init__.py,sha256=FHzL2Kx7_4FCgaaLxzb_RdTRDQgF-CraofLgc2IdSqs,639
-job_shop_lib/_base_solver.py,sha256=p17XmtufNc9Y481cqZUT45pEkUmmW1HWG53dfhIBJH8,1363
-job_shop_lib/_job_shop_instance.py,sha256=FkMBy9Yb8cNEGswI9vlN3Wh4mhtEX-QuDbKvSYUOXcM,18361
-job_shop_lib/_operation.py,sha256=lwCjgXwWlgESFuV3Yh4SCVofPGCd3hJU4vnK7peREac,4235
-job_shop_lib/_schedule.py,sha256=3PgDZ-DZmlESh5TASNHTqW_8Z7XPVSF64knvXEGRIbM,12927
+job_shop_lib/__init__.py,sha256=7AD9gwI3xXZonyTg82RJ8dhTXg1QdRJpL3HA0Y7TElg,639
+job_shop_lib/_base_solver.py,sha256=8CCSiA2-DegCKRXhMw7yYyI8iPauTSuLku2LQ8dU-9U,1382
+job_shop_lib/_job_shop_instance.py,sha256=_92orxdi70645J7cQlRE1I0PebvpHRCP6958q9j2h18,24261
+job_shop_lib/_operation.py,sha256=JI5WjvRXNBeSpPOv3ZwSrUJ4jsVDJYKfMaDHYOaFYts,5945
+job_shop_lib/_schedule.py,sha256=u0clgm2OTUsTstwd_AQeGQWANhmbWRrPPsKAc62iel4,17783
 job_shop_lib/_scheduled_operation.py,sha256=czrGr87EOTlO2NPolIN5CDigeiCzvQEyra5IZPwSFZc,2801
 job_shop_lib/benchmarking/__init__.py,sha256=JPnCw5mK7sADAW0HctVKHEDRw22afp9caNh2eUS36Ys,3290
 job_shop_lib/benchmarking/_load_benchmark.py,sha256=-cgyx0Kn6uAc3KdGFSQb6eUVQjQggmpVKOH9qusNkXI,2930
 job_shop_lib/benchmarking/benchmark_instances.json,sha256=F9EvyzFwVxiKAN6rQTsrMhsKstmyUmroyWduM7a00KQ,464841
 job_shop_lib/constraint_programming/__init__.py,sha256=kKQRUxxS_nVFUdXGnf4bQOD9mqrXxZZWElS753A4YiA,454
-job_shop_lib/constraint_programming/_ortools_solver.py,sha256=LMpfpgiU2etrtyVTKVKyZW1PVMrOG2TenWzfGuEGf2I,12710
+job_shop_lib/constraint_programming/_ortools_solver.py,sha256=trTQtqSL2F2PXxd9RPnFhxaY8blNcfFUhTdab5QP9VU,12585
 job_shop_lib/dispatching/__init__.py,sha256=gbgY1_lhergmXaDa-VYVUmxMpOKzYko0ONREVAt_QPc,2643
-job_shop_lib/dispatching/_dispatcher.py,sha256=KnV_Kry3Ie81WbKhdpRQtOMsuFDNCuh5Kp2ZnelM-R8,23835
+job_shop_lib/dispatching/_dispatcher.py,sha256=A54Q3_hm9Qy5Vfzeudj2QFxd9SWo9lqqBN55S6z-Who,23976
 job_shop_lib/dispatching/_dispatcher_observer_config.py,sha256=QF2d3rJWwmvutQBAkKxzQ1toJs6eMelT404LGS2z9HQ,2467
 job_shop_lib/dispatching/_factories.py,sha256=j3MhIwVXiq-B8JMit72ObvXSa2sdgWNhUD86gghL6Gg,4689
 job_shop_lib/dispatching/_history_observer.py,sha256=Vl8rQaxekUeEB-AyNxyC3c76zQakeh-rdri2iDnZvXw,610
 job_shop_lib/dispatching/_optimal_operations_observer.py,sha256=2EYxevjpeGMP3do-m0ZmtmjIjmNcxrWOSKzN_bW37gQ,4247
-job_shop_lib/dispatching/_ready_operation_filters.py,sha256=brhmhoyyoZ98wAEEfneZC-CD-aw9SerZHGMB1DpK8HY,5749
+job_shop_lib/dispatching/_ready_operation_filters.py,sha256=DcwPDIF1eqVR6s3DV4J3cumii0N_apC13XA-50wjlI0,5822
 job_shop_lib/dispatching/_start_time_calculators.py,sha256=N4kz3c4TmXbyFsY6ctxruYK2ucnjSVXWNMhvsUWFuDg,8192
 job_shop_lib/dispatching/_unscheduled_operations_observer.py,sha256=0he-j4OlvqtXAJZD5x1nuBnUKqZUfftVx9NT3CVxPyg,2708
-job_shop_lib/dispatching/feature_observers/__init__.py,sha256=EuJLvSpJpoXUK8A4UuC2k6Mpa293ZR3oCnnvYivIBtU,2240
+job_shop_lib/dispatching/feature_observers/__init__.py,sha256=Pzud4tuO_t72d9KY_nEH-stGOvKUTNjo_6GeWDuJPvc,2322
 job_shop_lib/dispatching/feature_observers/_composite_feature_observer.py,sha256=tpvqTLIcNmbYROSFT62LiUZ_tI4fHWL_qCULKK43BU4,6429
-job_shop_lib/dispatching/feature_observers/_duration_observer.py,sha256=fbkUIVScF1iNjdVCYr1ImQm53TfahvVnGXhsRAsgdzY,4129
+job_shop_lib/dispatching/feature_observers/_dates_observer.py,sha256=oCk1XAo_2mrgD0ckHQLw3dD7DSQVVg7xBKn7D_u1Dvc,6083
+job_shop_lib/dispatching/feature_observers/_duration_observer.py,sha256=pBsJjT-1pbSi32hoLppoqXCftBvJPSh7r7tl3m7etAQ,4225
 job_shop_lib/dispatching/feature_observers/_earliest_start_time_observer.py,sha256=AQIjVp7VRDnb5GuYZlLUwk-xiXSqbsxJW-Ji7NjLoAw,11452
 job_shop_lib/dispatching/feature_observers/_factory.py,sha256=NyXYK5A1hXsYEeEqngwVRNAFkevY95DglheeqyfFv8s,3217
 job_shop_lib/dispatching/feature_observers/_feature_observer.py,sha256=qbgtMUicQ5FWS-Ql4Izjsj4QrevfOGlWzoJ0JlVSLH0,8668
@@ -29,17 +30,17 @@ job_shop_lib/dispatching/feature_observers/_is_ready_observer.py,sha256=wy_pA-1w
 job_shop_lib/dispatching/feature_observers/_is_scheduled_observer.py,sha256=OcuMUB9_By6ZMtX-1_3z-xaxGbP85a5Zv0ywAv7XxWQ,1491
 job_shop_lib/dispatching/feature_observers/_position_in_job_observer.py,sha256=WRknpQBKXs6h6cXLFJW7ZCvjtU8CPL-iXXNPw3g-mLE,1303
 job_shop_lib/dispatching/feature_observers/_remaining_operations_observer.py,sha256=5V87lCrJUabEe8AkTGXPu5yS8OGxeN8L3-xNyHmdmLs,1441
-job_shop_lib/dispatching/rules/__init__.py,sha256=0Nn9FBVmxVYeDeLsd7g7WkmKFBYJqOIDzArbqsC7FAI,2187
-job_shop_lib/dispatching/rules/_dispatching_rule_factory.py,sha256=5fNpv90fAoR6rcE6NeJOWiB7ir-FVnoONIhHtKJ9H0E,2904
+job_shop_lib/dispatching/rules/__init__.py,sha256=u1XCRU4tVXJ2rdxXQabPIBaRly0PbBmBu1QcEKx9Z_Y,2396
+job_shop_lib/dispatching/rules/_dispatching_rule_factory.py,sha256=iwqGHtroZAuE90fKOAe79reHlJ8gCnJzMjCkI0lucMg,3101
 job_shop_lib/dispatching/rules/_dispatching_rule_solver.py,sha256=1_canC1lXZATrQCZaHOY3JOLmTuT6U0Z_QWzgTOLwqI,5917
-job_shop_lib/dispatching/rules/_dispatching_rules_functions.py,sha256=Yk40aKePBHHiMO6aTFeyJd1-khsDPhqit2WCOaByCfw,10998
+job_shop_lib/dispatching/rules/_dispatching_rules_functions.py,sha256=c-T6jUXZ2wjkmENBlDfNyWUA4T3inGll1E0jqAn6wd8,12052
 job_shop_lib/dispatching/rules/_machine_chooser_factory.py,sha256=CJ74ujgWXgG8cuULWY6VJkD_b3arTcOjTNLZJTAf8xE,2346
 job_shop_lib/dispatching/rules/_utils.py,sha256=m5qw4qyfaIvVrkmv51nuhreizr98-cg8AJKt2VTd48w,4603
 job_shop_lib/exceptions.py,sha256=ARzpoZJCvRIvOesCiqqFSRxkv6w9WwEXx0aBP-l2IKA,1597
 job_shop_lib/generation/__init__.py,sha256=QaWwuBfBNnOiG0OPiP_CV_flBu9dX7r2o_HwL47tREM,822
 job_shop_lib/generation/_general_instance_generator.py,sha256=b_tnyP4H_buoN7b6lKQRLvDkeZDdys0mpqS3thB5-SQ,6544
 job_shop_lib/generation/_instance_generator.py,sha256=doN6WySyI0k7wz3aKy_e6hj6t7WV3dNzve3YmTFShas,4584
-job_shop_lib/generation/_utils.py,sha256=TYBGt4Zjw94l6ukIjXBVAK3lmrrZXdyzyq_r1DMlL-E,3986
+job_shop_lib/generation/_utils.py,sha256=b3SVU5DY3-VHXX2yrOwM7ABDSexiSFSRbo1d5QjRfoI,3972
 job_shop_lib/graphs/__init__.py,sha256=wlYIiXTuZRE6Kx3K0RpPUoZikzoegBuN2hcdqMODtGk,2433
 job_shop_lib/graphs/_build_disjunctive_graph.py,sha256=UbUYdeQaaeEqLchcKJGHEFGl4wElfGLb1o_R-u8wqnA,5120
 job_shop_lib/graphs/_build_resource_task_graphs.py,sha256=vIy_EkQjgQAd5YyJxKAuGf7CLTjgCfhz-fYrObF4DTU,6962
@@ -51,6 +52,11 @@ job_shop_lib/graphs/graph_updaters/_disjunctive_graph_updater.py,sha256=-t0T8W-J
 job_shop_lib/graphs/graph_updaters/_graph_updater.py,sha256=j1f7iWsa62GVszK2BPaMxnKBCEGWa9owm8g4VWUje8w,1967
 job_shop_lib/graphs/graph_updaters/_residual_graph_updater.py,sha256=9NG3pu7Z5h-ZTfX8rRiZbI_NfNQi80h-XUHainshjZY,6064
 job_shop_lib/graphs/graph_updaters/_utils.py,sha256=sdw2Vo75P9c6Fy-YBlfgpXb9gPwHUluTB1E-9WINm_g,730
+job_shop_lib/metaheuristics/__init__.py,sha256=z7bHN5vP-ctOSL0eUYK-aRyhRkU2lrDyA4kBs15EME0,1884
+job_shop_lib/metaheuristics/_job_shop_annealer.py,sha256=Ty4SLPZh1NrL-XRqU76EeN8fwUdKfqbphqfYEDje1lQ,9195
+job_shop_lib/metaheuristics/_neighbor_generators.py,sha256=3RePlnYvJdpdhObmf0m_3NhyUM7avfNr4vOZT0PWTRQ,6563
+job_shop_lib/metaheuristics/_objective_functions.py,sha256=GG5M3LoLnNzo1zxzfpNMvo4bdYlqWuhVA8mIkXFsxxM,2607
+job_shop_lib/metaheuristics/_simulated_annealing_solver.py,sha256=EMCrFl2zzJubrvCMi5upm8lnUgtBizhZbi4EvbnIsM4,6200
 job_shop_lib/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 job_shop_lib/reinforcement_learning/__init__.py,sha256=sAVgxylKfBnn2rrz0BFcab1kjvQQ1h-hgldfbkPF--E,1537
 job_shop_lib/reinforcement_learning/_multi_job_shop_graph_env.py,sha256=6nXw67Tfmim3LqlSuQ9Cfg3mMY-VmbMHuXfyOL90jng,15740
@@ -67,7 +73,7 @@ job_shop_lib/visualization/gantt/_plot_gantt_chart.py,sha256=_4UGUTRuIw0tLzsJD9G
 job_shop_lib/visualization/graphs/__init__.py,sha256=HUWzfgQLeklNROtjnxeJX_FIySo_baTXO6klx0zUVpQ,630
 job_shop_lib/visualization/graphs/_plot_disjunctive_graph.py,sha256=L9_ZGgvCFpGc2rTOdZESdtydFQqShjqedimIOhqZx6Y,16209
 job_shop_lib/visualization/graphs/_plot_resource_task_graph.py,sha256=nkkdZ-9_OBevw72Frecwzv1y3WyhGZ9r9lz0y9MXvZ8,13192
-job_shop_lib-1.3.0.dist-info/LICENSE,sha256=9mggivMGd5taAu3xbmBway-VQZMBzurBGHofFopvUsQ,1069
-job_shop_lib-1.3.0.dist-info/METADATA,sha256=oVgHOo9l8-crgD3w_uiR5zU6B0m9gxRAI0IPu7pSnpU,19130
-job_shop_lib-1.3.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-job_shop_lib-1.3.0.dist-info/RECORD,,
+job_shop_lib-1.6.0.dist-info/LICENSE,sha256=9mggivMGd5taAu3xbmBway-VQZMBzurBGHofFopvUsQ,1069
+job_shop_lib-1.6.0.dist-info/METADATA,sha256=cDfJquD-2ph8c7Niv0_hZ_OGI_1fOmJLe-nNoXVS96s,19250
+job_shop_lib-1.6.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+job_shop_lib-1.6.0.dist-info/RECORD,,