PyJobShop

https://pyjobshop.org/stable/
Admin
PyJobShop is a Python library for solving scheduling problems using constraint programming,...
Tokens:29,004
Snippets:292
Trust Score:4.9
Update:5 months ago
Show doc for...
Tokens:
Raw
### Install PyJobShop

Source: https://pyjobshop.org/stable/index.html

Install the PyJobShop library using pip. This command should be run in your terminal or command prompt.

```bash
pip install pyjobshop

```

--------------------------------

### Install PyJobShop with CP Optimizer support

Source: https://pyjobshop.org/stable/setup/installation.html

Install PyJobShop along with the 'docplex' dependency to enable integration with IBM ILOG CP Optimizer. This assumes you already have CP Optimizer installed.

```bash
pip install pyjobshop[docplex]
```

--------------------------------

### add_start_at_start

Source: https://pyjobshop.org/stable/api/pyjobshop.html

Adds a StartAtStart constraint. Task 2 must start exactly at the start of Task 1 plus a delay.

```APIDOC
## add_start_at_start

### Description
Adds a constraint that task 2 must start exactly at the start of task 1 plus the delay.

### Signature
`add_start_at_start(_task1: Task_, _task2: Task_, _delay: int = 0) -> StartAtStart`

### Parameters
- `_task1` (Task): The reference task.
- `_task2` (Task): The task that must start at a specific time relative to task1.
- `_delay` (int, optional): The delay added to the start time of task1. Defaults to 0.

### Returns
- `StartAtStart`: The newly added StartAtStart constraint object.
```

--------------------------------

### Install PyJobShop from GitHub

Source: https://pyjobshop.org/stable/setup/installation.html

Install the latest development version of PyJobShop directly from its GitHub repository. This is useful for accessing unreleased features.

```bash
pip install 'pyjobshop @ git+https://github.com/PyJobShop/PyJobShop'
```

--------------------------------

### _class _StartAtStart

Source: https://pyjobshop.org/stable/api/pyjobshop.html

Represents a constraint where one task must start at the same time another task starts, with an optional delay.

```APIDOC
## _class _StartAtStart

### Description
Start task 1 (s1) at the start of task 2 (s2), with an optional delay d. That is, s1+d=s2.

### Parameters
- **task1** (int) - Required - The index of the first task.
- **task2** (int) - Required - The index of the second task.
- **delay** (int) - Optional - The delay in time units. Defaults to 0.
```

--------------------------------

### Define Model with Sequence-Dependent Setup Times

Source: https://pyjobshop.org/stable/examples/quick_examples.html

Sets up a job shop model with tasks and machines, defining processing times and sequence-dependent setup times between tasks on each machine. Instances with sequence-dependent setup times are generally hard to solve.

```python
model = Model()
tasks = [model.add_task() for _ in range(6)]
machines = [model.add_machine() for _ in range(2)]

for task in tasks:
    # The first machine is faster than the second machine.
    model.add_mode(task, machines[0], duration=1)
    model.add_mode(task, machines[1], duration=3)

for task1 in tasks:
    for task2 in tasks:
        model.add_setup_time(machines[0], task1, task2, duration=1)
        model.add_setup_time(machines[1], task1, task2, duration=2)
```

--------------------------------

### add_start_before_start

Source: https://pyjobshop.org/stable/api/pyjobshop.html

Adds a StartBeforeStart constraint. Task 1 must start before Task 2 starts, with an optional delay.

```APIDOC
## add_start_before_start

### Description
Adds a constraint that task 1 must start before task 2 starts, with an optional delay.

### Signature
`add_start_before_start(_task1: Task_, _task2: Task_, _delay: int = 0) -> StartBeforeStart`

### Parameters
- `_task1` (Task): The first task.
- `_task2` (Task): The second task.
- `_delay` (int, optional): The minimum delay between the start of task1 and the start of task2. Defaults to 0.

### Returns
- `StartBeforeStart`: The newly added StartBeforeStart constraint object.
```

--------------------------------

### add_setup_time

Source: https://pyjobshop.org/stable/api/pyjobshop.html

Adds a setup time between two tasks on a machine.

```APIDOC
## add_setup_time

### Description
Adds a setup time between two tasks on a machine.

### Signature
add_setup_time(_machine : Machine_, _task1 : Task_, _task2 : Task_, _duration : int_) → SetupTime
```

--------------------------------

### add_start_at_start

Source: https://pyjobshop.org/stable/api/pyjobshop.html

Adds a constraint that task 2 must start exactly at the start of task 1 plus the delay.

```APIDOC
## add_start_at_start

### Description
Adds a constraint that task 2 must start exactly at the start of task 1 plus the delay.

### Signature
add_start_at_start(_task1 : Task_, _task2 : Task_, _delay : int = `0`_) → StartAtStart
```

--------------------------------

### SetupTime Constraint

Source: https://pyjobshop.org/stable/api/pyjobshop.html

Defines a sequence-dependent setup time between two tasks on a specific machine.

```APIDOC
## SetupTime Constraint

### Description
Sequence-dependent setup time between task 1 and task 2 on the given machine. Let e1 be the end time of task 1 and let s2 be the start time of task 2. If the selected modes of task 1 and task 2 both require the given machine, then this constraint ensures that e1+d≤s2, where d is the setup time duration. Note that this also implies an end-before-start relationship between task 1 and task 2. When using `Machine.breaks`, setup times are allowed to take place during the breaks.

### Parameters
- **machine** (int) - Required - The machine on which the setup time occurs.
- **task1** (int) - Required - The first task.
- **task2** (int) - Required - The second task.
- **duration** (int) - Required - The duration of the setup time.
```

--------------------------------

### Initialize Model and Add Jobs/Tasks

Source: https://pyjobshop.org/stable/examples/objectives.html

Sets up a PyJobShop Model with machines, jobs, tasks, and modes. Includes defining setup times between tasks.

```python
from pyjobshop import Model

model = Model()
machine = model.add_machine()

jobs = [
    model.add_job(due_date=12),
    model.add_job(due_date=1),
]
tasks = [model.add_task(job=job) for job in jobs]
modes = [model.add_mode(task, machine, duration=1) for task in tasks]
model.add_setup_time(machine, tasks[1], tasks[0], 10);
```

--------------------------------

### Install PyJobShop with CP Optimizer community edition

Source: https://pyjobshop.org/stable/setup/installation.html

Install PyJobShop with both 'docplex' and 'cplex' dependencies to use the free community edition of CP Optimizer. This edition is limited to 1000 variables and 1000 constraints.

```bash
pip install pyjobshop[docplex,cplex]
```

--------------------------------

### Set Up Virtual Environment with uv

Source: https://pyjobshop.org/stable/dev/contributing.html

Navigate to the PyJobShop directory and install all project dependencies, including extras and all groups, using uv. Ensure you have uv v0.5.4 or above.

```bash
cd PyJobShop
uv sync --all-extras --all-groups
```

--------------------------------

### add_setup_time

Source: https://pyjobshop.org/stable/api/pyjobshop.html

Adds a SetupTime constraint. Specifies a setup time required between two tasks on a machine.

```APIDOC
## add_setup_time

### Description
Adds a setup time between two tasks on a machine.

### Signature
`add_setup_time(_task1: Task_, _task2: Task_, _setup_time: int, _machine: Machine_)`

### Parameters
- `_task1` (Task): The first task.
- `_task2` (Task): The second task.
- `_setup_time` (int): The setup time required between task1 and task2.
- `_machine` (Machine): The machine on which the setup time occurs.

### Returns
- `SetupTime`: The newly added SetupTime constraint object.
```

--------------------------------

### _class _StartBeforeStart

Source: https://pyjobshop.org/stable/api/pyjobshop.html

Represents a constraint where one task must start before another task starts, with an optional delay.

```APIDOC
## _class _StartBeforeStart

### Description
Start task 1 (s1) before task 2 starts (s2), with an optional delay d. That is, s1+d≤s2.

### Parameters
- **task1** (int) - Required - The index of the first task.
- **task2** (int) - Required - The index of the second task.
- **delay** (int) - Optional - The delay in time units. Defaults to 0.
```

--------------------------------

### Initialize PyJobShop Model

Source: https://pyjobshop.org/stable/examples/simple_example.html

Instantiates the Model object from the pyjobshop library. Ensure PyJobShop is installed via 'pip install pyjobshop' if using in an environment like Google Colab.

```python
from pyjobshop import Model

model = Model()
```

--------------------------------

### Install pre-commit Hooks

Source: https://pyjobshop.org/stable/dev/contributing.html

Set up pre-commit hooks using uv to automatically check for style and typing issues upon each commit. This helps maintain code quality.

```bash
uv run pre-commit install
```

--------------------------------

### _class _StartBeforeEnd

Source: https://pyjobshop.org/stable/api/pyjobshop.html

Represents a constraint where one task must start before another task ends, with an optional delay.

```APIDOC
## _class _StartBeforeEnd

### Description
Start task 1 (s1) before task 2 ends (e2), with an optional delay d. That is, s1+d≤e2.

### Parameters
- **task1** (int) - Required - The index of the first task.
- **task2** (int) - Required - The index of the second task.
- **delay** (int) - Optional - The delay in time units. Defaults to 0.
```

--------------------------------

### Conditional Selection Constraint Example

Source: https://pyjobshop.org/stable/examples/optional_tasks.html

Demonstrates how to use the 'condition_task' parameter to create conditional selection rules. This example enforces that if task X is scheduled, then exactly one of tasks A, B, or C must also be scheduled.

```python
model.add_select_exactly_one([A, B, C], condition_task=X);
```

--------------------------------

### Run Test Suite with uv

Source: https://pyjobshop.org/stable/dev/contributing.html

Execute the project's test suite using uv and pytest to ensure the installation is successful and all components function correctly.

```bash
uv run pytest
```

--------------------------------

### Add Synchronized Tasks

Source: https://pyjobshop.org/stable/examples/breaks.html

Adds a long processing task for a machine and a short setup task requiring operator supervision. Both tasks are linked to start simultaneously.

```python
job = model.add_job()
processing_task = model.add_task(job, name="processing")
model.add_mode(processing_task, machine, duration=15)

setup_task = model.add_task(job, name="setup")
model.add_mode(setup_task, operator, duration=1)
```

--------------------------------

### Model Setup for Blocking PFSP

Source: https://pyjobshop.org/stable/examples/permutation_flow_shop.html

Initializes the model, jobs, machines, and tasks for a blocking PFSP. Tasks are configured to allow idle time, and end-at-start constraints are added between consecutive tasks of the same job.

```python
model = Model()

jobs = [model.add_job() for _ in range(num_jobs)]
machines = [model.add_machine() for _ in range(num_machines)]
tasks = {}

for job_idx, job in enumerate(jobs):
    for machine_idx, machine in enumerate(machines):
        task = model.add_task(job=job, allow_idle=True)
        tasks[job_idx, machine_idx] = task

        duration = DURATIONS[job_idx][machine_idx]
        model.add_mode(task, machine, duration=duration)

for job_idx in range(num_jobs):
    for idx1, idx2 in pairwise(range(num_machines)):
        task1 = tasks[job_idx, idx1]
        task2 = tasks[job_idx, idx2]
        model.add_end_at_start(task1, task2)
```

--------------------------------

### Print Job Start and End Times

Source: https://pyjobshop.org/stable/examples/objectives.html

Iterates through the solved model's jobs to print their start and end times. Useful for analyzing the schedule.

```python
for idx, job in enumerate(result.best.jobs):
    start, end = job.start, job.end
    print(f"Job {idx}: start={job.start}, end={job.end}")
```

--------------------------------

### Import PyJobShop Model

Source: https://pyjobshop.org/stable/examples/optional_tasks.html

Import the Model class from the pyjobshop library to start defining scheduling problems.

```python
from pyjobshop import Model
```

--------------------------------

### _class _StartAtEnd

Source: https://pyjobshop.org/stable/api/pyjobshop.html

Represents a constraint where one task must start at the same time another task ends, with an optional delay.

```APIDOC
## _class _StartAtEnd

### Description
Start task 1 (s1) at the end of task 2 (e2), with an optional delay d. That is, s1+d=e2.

### Parameters
- **task1** (int) - Required - The index of the first task.
- **task2** (int) - Required - The index of the second task.
- **delay** (int) - Optional - The delay in time units. Defaults to 0.
```

--------------------------------

### Print Model Summary

Source: https://pyjobshop.org/stable/examples/simple_example.html

Prints a summary of the configured model, including the number of jobs, resources, tasks, modes, constraints, and the objective function. This is useful for verifying the model setup.

```python
print(model.summary())
```

--------------------------------

### add_start_before_end

Source: https://pyjobshop.org/stable/api/pyjobshop.html

Adds a StartBeforeEnd constraint. Task 1 must start before Task 2 ends, with an optional delay.

```APIDOC
## add_start_before_end

### Description
Adds a constraint that task 1 must start before task 2 ends, with an optional delay.

### Signature
`add_start_before_end(_task1: Task_, _task2: Task_, _delay: int = 0) -> StartBeforeEnd`

### Parameters
- `_task1` (Task): The first task.
- `_task2` (Task): The second task.
- `_delay` (int, optional): The minimum delay between the start of task1 and the end of task2. Defaults to 0.

### Returns
- `StartBeforeEnd`: The newly added StartBeforeEnd constraint object.
```

--------------------------------

### Run Tests for OR-Tools Solver Only

Source: https://pyjobshop.org/stable/dev/contributing.html

If encountering installation issues with CP Optimizer, run the test suite specifically for the OR-Tools solver by specifying the --solvers argument.

```bash
uv run pytest --solvers ortools
```

--------------------------------

### Add Start-at-Start Constraint

Source: https://pyjobshop.org/stable/examples/breaks.html

Enforces a start-at-start constraint between two tasks, ensuring that one task cannot begin until the other has also started.

```python
model.add_start_at_start(processing_task, setup_task)
```

--------------------------------

### add_end_at_start

Source: https://pyjobshop.org/stable/api/pyjobshop.html

Adds an EndAtStart constraint. Task 2 must start exactly at the end of Task 1 plus a delay.

```APIDOC
## add_end_at_start

### Description
Adds a constraint that task 2 must start exactly at the end of task 1 plus the delay.

### Signature
`add_end_at_start(_task1: Task_, _task2: Task_, _delay: int = 0) -> EndAtStart`

### Parameters
- `_task1` (Task): The reference task.
- `_task2` (Task): The task that must start at a specific time relative to task1's end.
- `_delay` (int, optional): The delay added to the end time of task1. Defaults to 0.

### Returns
- `EndAtStart`: The newly added EndAtStart constraint object.
```

--------------------------------

### Define Model for Feasible Solution Search

Source: https://pyjobshop.org/stable/examples/quick_examples.html

Initializes a job shop model with tasks and machines, defining processing modes. This setup is used to demonstrate finding a feasible solution quickly.

```python
model = Model()
tasks = [model.add_task(name=idx) for idx in range(6)]
machines = [model.add_machine(name=idx) for idx in range(2)]

for task in tasks:
    model.add_mode(task, machines[0], duration=1)
    model.add_mode(task, machines[1], duration=3)
```

--------------------------------

### Import PyJobShop Libraries

Source: https://pyjobshop.org/stable/examples/quick_examples.html

Import the necessary Model and plotting functions from PyJobShop. Ensure PyJobShop is installed, especially in environments like Google Colab.

```python
from pyjobshop import Model
from pyjobshop.plot import plot_machine_gantt
```

--------------------------------

### _class _EndAtStart

Source: https://pyjobshop.org/stable/api/pyjobshop.html

Represents a constraint where one task must end at the same time another task starts, with an optional delay.

```APIDOC
## _class _EndAtStart

### Description
End task 1 (e1) at the start of task 2 (s2), with an optional delay d. That is, e1+d=s2.

### Parameters
- **task1** (int) - Required - The index of the first task.
- **task2** (int) - Required - The index of the second task.
- **delay** (int) - Optional - The delay in time units. Defaults to 0.
```

--------------------------------

### add_start_at_end

Source: https://pyjobshop.org/stable/api/pyjobshop.html

Adds a StartAtEnd constraint. Task 2 must end exactly at the start of Task 1 plus a delay.

```APIDOC
## add_start_at_end

### Description
Adds a constraint that task 2 must end exactly at the start of task 1 plus the delay.

### Signature
`add_start_at_end(_task1: Task_, _task2: Task_, _delay: int = 0) -> StartAtEnd`

### Parameters
- `_task1` (Task): The reference task.
- `_task2` (Task): The task whose end time is constrained.
- `_delay` (int, optional): The delay added to the start time of task1. Defaults to 0.

### Returns
- `StartAtEnd`: The newly added StartAtEnd constraint object.
```

--------------------------------

### add_end_before_start

Source: https://pyjobshop.org/stable/api/pyjobshop.html

Adds a constraint that task 1 must end before task 2 starts, with an optional delay.

```APIDOC
## add_end_before_start

### Description
Adds a constraint that task 1 must end before task 2 starts, with an optional delay.

### Signature
add_end_before_start(_task1 : Task_, _task2 : Task_, _delay : int = `0`_) → EndBeforeStart
```

--------------------------------

### add_end_before_start

Source: https://pyjobshop.org/stable/api/pyjobshop.html

Adds an EndBeforeStart constraint. Task 1 must end before Task 2 starts, with an optional delay.

```APIDOC
## add_end_before_start

### Description
Adds a constraint that task 1 must end before task 2 starts, with an optional delay.

### Signature
`add_end_before_start(_task1: Task_, _task2: Task_, _delay: int = 0) -> EndBeforeStart`

### Parameters
- `_task1` (Task): The first task.
- `_task2` (Task): The second task.
- `_delay` (int, optional): The minimum delay between the end of task1 and the start of task2. Defaults to 0.

### Returns
- `EndBeforeStart`: The newly added EndBeforeStart constraint object.
```

--------------------------------

### Print Makespan and Total Tardiness

Source: https://pyjobshop.org/stable/examples/objectives.html

Displays the makespan and total tardiness from the solved model, along with individual job start, end, and tardiness values.

```python
print(f"Makespan = {result.best.makespan}")
print(f"Total tardiness = {result.best.total_tardiness}")

for idx, job in enumerate(result.best.jobs):
    start, end, tardiness = job.start, job.end, job.tardiness
    print(f"Job {idx}: start={start}, end={end}, tardiness={tardiness}")
```

--------------------------------

### add_end_at_start

Source: https://pyjobshop.org/stable/api/pyjobshop.html

Adds a constraint that task 2 must start exactly at the end of task 1 plus the delay.

```APIDOC
## add_end_at_start

### Description
Adds a constraint that task 2 must start exactly at the end of task 1 plus the delay.

### Signature
add_end_at_start(_task1 : Task_, _task2 : Task_, _delay : int = `0`_) → EndAtStart
```

--------------------------------

### Add Precedence Constraints

Source: https://pyjobshop.org/stable/examples/optional_tasks.html

Defines and adds 'end before start' precedence constraints between tasks. These constraints only apply if both the predecessor and successor tasks are selected.

```python
precedence = [
    ("source", "C-A"),
    ("source", "C-B"),
    ("C-A", "I-A"),
    ("C-A", "C-AB"),
    ("C-B", "C-AB"),
    ("C-B", "I-B"),
    ("C-AB", "I-AB"),
    ("I-A", "I-B"),
    ("I-A", "target"),
    ("I-B", "target"),
    ("I-AB", "target"),
]

for pred, succ in precedence:
    model.add_end_before_start(tasks[pred], tasks[succ])
```

--------------------------------

### Define Model with No-Idle Machine Constraint

Source: https://pyjobshop.org/stable/examples/quick_examples.html

Sets up a model with a machine configured to operate continuously without idle time (`no_idle=True`). Tasks are scheduled back-to-back, respecting setup times.

```python
model = Model()
machine = model.add_machine(no_idle=True)

task1 = model.add_task(earliest_start=5, name="Task1")
task2 = model.add_task(name="Task2")

model.add_mode(task1, machine, duration=1)
model.add_mode(task2, machine, duration=2)

result = model.solve(display=False)
```

--------------------------------

### Display Scheduled Task Details

Source: https://pyjobshop.org/stable/examples/breaks.html

Retrieves and displays the details of scheduled tasks from the solution, including start time, end time, and break information.

```python
result.best.tasks
```

--------------------------------

### Inspect Solution Tasks

Source: https://pyjobshop.org/stable/examples/simple_example.html

Iterates through the tasks in the best found solution and prints details for each. Each ScheduledTask object contains information about its mode, assigned resources, start and end times.

```python
for task in result.best.tasks:
    print(task)
```

--------------------------------

### Define Machines and Task Durations

Source: https://pyjobshop.org/stable/examples/simple_example.html

Creates two machines and assigns processing times to each task. Task duration is determined by the job index plus one. This setup is crucial for defining the problem's constraints.

```python
machines = [model.add_machine() for _ in range(2)]

for job in range(len(jobs)):
    for task in tasks[job]:
        for machine in machines:
            duration = job + 1
            model.add_mode(task, machine, duration)
```

--------------------------------

### Set Objective for Makespan and Total Tardiness

Source: https://pyjobshop.org/stable/examples/objectives.html

Sets a combined objective to minimize both makespan and total tardiness with specified weights. The total tardiness is weighted twice as heavily as the makespan in this example.

```python
model.set_objective(weight_makespan=1, weight_total_tardiness=2)
result = model.solve(display=False)
print(result)
```

--------------------------------

### Initialize PyJobShop Model

Source: https://pyjobshop.org/stable/examples/project_scheduling.html

Sets up a PyJobShop Model instance and loads an RCPSP instance from a file. This is the initial step before defining scheduling constraints and solving.

```python
from pyjobshop import Model

instance = Instance.read_instance("data/j9041_6.sm")
model = Model()

```

--------------------------------

### Initialize HFS Model

Source: https://pyjobshop.org/stable/examples/hybrid_flow_shop.html

Sets up the basic structure for a hybrid flow shop problem, including machines, jobs, tasks, and modes.

```python
model = Model()

machines = [
    [model.add_machine(name=machine_name(k, m)) for m in range(num)]
    for k, num in enumerate(num_machines)
]

jobs = [model.add_job() for _ in range(num_jobs)]
tasks = {}
modes = {}

for j, job in enumerate(jobs):
    for k in range(num_stages):
        task = model.add_task(job, name=task_name(j, k))
        tasks[j, k] = task

    for k in range(num_stages):
        for m, machine in enumerate(machines[k]):
            task = tasks[j, k]
            duration = PROCESSING_TIMES[j, k]
            mode = model.add_mode(task, machine, duration)
            modes[j, k, m] = mode

    for k in range(num_stages - 1):
        first = tasks[j, k]
        second = tasks[j, k + 1]
        model.add_end_before_start(first, second)

```

--------------------------------

### Initialize Model, Tasks, and Resources for MMRCPSP

Source: https://pyjobshop.org/stable/examples/project_scheduling.html

Sets up the PyJobShop model, defines jobs, tasks, and resources (both renewable and consumable) for a multi-mode resource-constrained project scheduling problem.

```python
from pyjobshop import Model

instance = Instance.read_instance("data/r54_9.mm")
model = Model()

# It's not necessary to define jobs, but it will add coloring to the plot.
jobs = [model.add_job() for _ in range(instance.num_jobs)]
tasks = [model.add_task(job=jobs[idx]) for idx in range(instance.num_jobs)]
resources = [
    model.add_renewable(capacity=capacity)
    if renewable
    else model.add_consumable(capacity=capacity)
    for capacity, renewable in zip(instance.capacities, instance.renewable)
]
```

--------------------------------

### _class _EndBeforeStart

Source: https://pyjobshop.org/stable/api/pyjobshop.html

Represents a constraint where one task must end before another task starts, with an optional delay.

```APIDOC
## _class _EndBeforeStart

### Description
End task 1 (e1) before task 2 starts (s2), with an optional delay d. That is, e1+d≤s2.

### Parameters
- **task1** (int) - Required - The index of the first task.
- **task2** (int) - Required - The index of the second task.
- **delay** (int) - Optional - The delay in time units. Defaults to 0.
```

--------------------------------

### Configure Machine and Task Durations

Source: https://pyjobshop.org/stable/examples/optional_tasks.html

Sets up a single machine and assigns random durations (1-5 time units) to optional tasks, while source and target tasks have zero duration.

```python
import random

random.seed(42)

machine = model.add_machine()

model.add_mode(tasks["source"], machine, duration=0)
model.add_mode(tasks["target"], machine, duration=0)

for name in names:
    model.add_mode(tasks[name], machine, duration=random.randint(1, 5))
```

--------------------------------

### add_start_at_end

Source: https://pyjobshop.org/stable/api/pyjobshop.html

Adds a constraint that task 2 must end exactly at the start of task 1 plus the delay.

```APIDOC
## add_start_at_end

### Description
Adds a constraint that task 2 must end exactly at the start of task 1 plus the delay.

### Signature
add_start_at_end(_task1 : Task_, _task2 : Task_, _delay : int = `0`_) → StartAtEnd
```

--------------------------------

### Initialize Model and Tasks

Source: https://pyjobshop.org/stable/examples/optional_tasks.html

Initializes the PyJobShop model and defines source, target, and optional tasks. Source and target tasks have zero duration.

```python
model = Model()

tasks = {"source": model.add_task(name="source")}

names = ["C-A", "C-B", "C-AB", "I-A", "I-AB", "I-B"]
tasks |= {name: model.add_task(optional=True, name=name) for name in names}

tasks["target"] = model.add_task(name="target")
```

--------------------------------

### Show PyJobShop Version Information (Command Line)

Source: https://pyjobshop.org/stable/setup/getting_help.html

This command-line equivalent is useful for quickly checking PyJobShop version information without needing to open a Python script. It's recommended to include this output in bug reports.

```python
python -c 'import pyjobshop; pyjobshop.show_versions()'
```

--------------------------------

### summary

Source: https://pyjobshop.org/stable/api/pyjobshop.html

Returns a string representation of the model, summarizing the scheduling problem.

```APIDOC
## summary

### Description
Returns a summary of the model, which is the string representation of the ProblemData instance created by the model.

### Signature
`summary() -> str`

### Returns
- `str`: A string summary of the model.
```

--------------------------------

### Define Task Dependency

Source: https://pyjobshop.org/stable/examples/optional_tasks.html

Add a temporal constraint specifying that task A must finish before task B can start, if both are scheduled.

```python
model.add_end_before_start(A, B);
```

--------------------------------

### Initialize PyJobShop Model

Source: https://pyjobshop.org/stable/examples/flexible_job_shop.html

Initializes a new Model object from the PyJobShop library to begin defining the scheduling problem.

```python
from pyjobshop import Model

m = Model()

```

--------------------------------

### Solve the FJSP Model

Source: https://pyjobshop.org/stable/examples/flexible_job_shop.html

Solves the configured Flexible Job Shop Problem model using the `solve` method and prints the resulting solution summary.

```python
result = m.solve(display=False)
print(result)

```

--------------------------------

### Define Model and Tasks with Optionality

Source: https://pyjobshop.org/stable/examples/optional_tasks.html

Initialize a PyJobShop Model, add a machine, and define tasks A, B, and C as optional. Each task is assigned a mode with a specific duration on the machine.

```python
model = Model()

machine = model.add_machine()

A = model.add_task(optional=True, name="A")
B = model.add_task(optional=True, name="B")
C = model.add_task(optional=True, name="C")

model.add_mode(A, machine, duration=1)
model.add_mode(B, machine, duration=1)
model.add_mode(C, machine, duration=3);
```

--------------------------------

### Configure Task Modes and Precedence Constraints

Source: https://pyjobshop.org/stable/examples/flexible_job_shop.html

Sets the processing times for each task on eligible machines and defines the sequential order for tasks within the same job using end-before-start constraints.

```python
for job_idx, job_data in enumerate(data):
    for idx, task_data in enumerate(job_data):
        task = tasks[(job_idx, idx)]

        for duration, machine_idx in task_data:
            machine = machines[machine_idx]
            m.add_mode(task, machine, duration)

    for idx in range(len(job_data) - 1):
        first = tasks[(job_idx, idx)]
        second = tasks[(job_idx, idx + 1)]
        m.add_end_before_start(first, second)

```

--------------------------------

### Define FJSP Data Instance

Source: https://pyjobshop.org/stable/examples/flexible_job_shop.html

Sets up the data for a Flexible Job Shop Problem, including the number of machines and job task details with eligible machine assignments and processing times.

```python
NUM_MACHINES = 3

# Each job consists of a list of tasks. A task is represented
# by a list of tuples (processing_time, machine), denoting the eligible
# machine assignments and corresponding processing times.
data = [
    [  # Job with three tasks
        [(3, 0), (1, 1), (5, 2)],  # task with three eligible machine
        [(2, 0), (4, 1), (6, 2)],
        [(2, 0), (3, 1), (1, 2)],
    ],
    [
        [(2, 0), (3, 1), (4, 2)],
        [(1, 0), (5, 1), (4, 2)],
        [(2, 0), (1, 1), (4, 2)],
    ],
    [
        [(2, 0), (1, 1), (4, 2)],
        [(2, 0), (3, 1), (4, 2)],
        [(3, 0), (1, 1), (5, 2)],
    ],
]

```

--------------------------------

### Model Class Methods

Source: https://pyjobshop.org/stable/api/pyjobshop.html

The Model class provides a step-by-step interface for building a scheduling problem. Below are the methods available for adding components and constraints to the model.

```APIDOC
## Model Class Methods

### Description
Provides an interface for building a scheduling problem step-by-step.

### Methods
- `add_job`: Adds a job to the model.
- `add_machine`: Adds a machine to the model.
- `add_renewable`: Adds a renewable resource to the model.
- `add_consumable`: Adds a consumable resource to the model.
- `add_task`: Adds a task to the model.
- `add_mode`: Adds a processing mode to the model.
- `add_start_before_start`: Adds a constraint that task 1 must start before task 2 starts, with an optional delay.
- `add_start_before_end`: Adds a constraint that task 1 must start before task 2 ends, with an optional delay.
- `add_end_before_start`: Adds a constraint that task 1 must end before task 2 starts, with an optional delay.
- `add_end_before_end`: Adds a constraint that task 1 must end before task 2 ends, with an optional delay.
- `add_start_at_start`: Adds a constraint that task 2 must start exactly at the start of task 1 plus the delay.
- `add_start_at_end`: Adds a constraint that task 2 must end exactly at the start of task 1 plus the delay.
- `add_end_at_start`: Adds a constraint that task 2 must start exactly at the end of task 1 plus the delay.
- `add_end_at_end`: Adds a constraint that task 2 must end exactly at the end of task 1 plus the delay.
- `add_identical_resources`: Adds a constraint that two tasks must be scheduled with modes that require identical resources.
- `add_different_resources`: Adds a constraint that the two tasks must be scheduled with modes that require different resources.
- `add_consecutive`: Adds a constraint that the first task must be scheduled right before the second task, meaning that no task is allowed to be scheduled between, on machines that they are both scheduled on.
- `add_same_sequence`: Adds a constraint that requires the two machines to schedule its tasks in the same sequence.
- `add_setup_time`: Adds a setup time between two tasks on a machine.
- `add_mode_dependency`: Adds a mode dependency between one mode and a list of modes, meaning that if the first mode has been selected, one out of the list of modes must be selected.
- `add_select_all_or_none`: Adds a constraint that all tasks from the given list are selected, or none are.
- `add_select_at_least_one`: Adds a constraint that at least one task from the given list is selected.
- `add_select_exactly_one`: Adds a constraint that exactly one task from the given list is selected.
- `set_objective`: Sets the objective function in this model.
- `summary`: Returns a summary of the model.
- `from_data`: Creates a Model instance from a ProblemData instance.
- `data`: Returns a ProblemData object containing the problem instance.
- `solve`: Solves the problem data instance created by the model.
```

--------------------------------

### Plot Gantt Chart for PFSP No-Idle Solution in Python

Source: https://pyjobshop.org/stable/examples/permutation_flow_shop.html

Visualize the schedule of the best solution found for the no-idle PFSP using a machine Gantt chart. This helps in observing task placements and machine utilization.

```python
plot_machine_gantt(result.best, model.data())
```

--------------------------------

### Manually Run pre-commit Checks

Source: https://pyjobshop.org/stable/dev/contributing.html

Manually execute pre-commit checks across all files in the project to ensure compliance with style and typing standards before committing.

```bash
uv run pre-commit run --all-files
```

--------------------------------

### Analyze Task Durations in Blocking PFSP

Source: https://pyjobshop.org/stable/examples/permutation_flow_shop.html

Iterates through the first ten tasks of the best solution to print their total duration, processing time, and idle time. This is used to verify that tasks are occupying machines longer than their processing time due to blocking.

```python
for sol_task in result.best.tasks[:10]:
    duration = sol_task.duration
    processing = sol_task.processing
    idle = sol_task.idle

    print(f"{duration = } | {processing = } | {idle = }")
```

--------------------------------

### Plot Task Gantt Chart

Source: https://pyjobshop.org/stable/examples/optional_tasks.html

Visualizes the optimal solution as a Gantt chart, displaying task execution times and respecting precedence constraints.

```python
plot_task_gantt(result.best, model.data(), plot_labels=True)
```

--------------------------------

### from_data

Source: https://pyjobshop.org/stable/api/pyjobshop.html

Creates a Model instance from existing problem data.

```APIDOC
## from_data

### Description
Creates a Model instance from a ProblemData instance.

### Signature
`from_data(_data: ProblemData_) -> Model`

### Parameters
- `_data` (ProblemData): The problem data to load.

### Returns
- `Model`: A new Model instance initialized with the provided data.
```

--------------------------------

### Solve for First Feasible Solution

Source: https://pyjobshop.org/stable/examples/quick_examples.html

Solves the model to find the first feasible solution, rather than the optimal one, by setting `stop_after_first_solution=True`. This is useful when only a valid schedule is needed quickly.

```python
result = model.solve(display=False, stop_after_first_solution=True)
print(result)
```

--------------------------------

### Parse PSPLIB Instance for RCPSP

Source: https://pyjobshop.org/stable/examples/project_scheduling.html

Reads and stores project scheduling instance data from a PSPLIB formatted file. Assumes the file contains precedence relations, requests/durations, and resource availabilities.

```python
import re
from dataclasses import dataclass
from typing import NamedTuple


class Mode(NamedTuple):
    job: int
    duration: int
    demands: list[int]


@dataclass(frozen=True)
class Instance:
    """
    Problem instance class based on PSPLIB files.

    Code taken from:
    https://alns.readthedocs.io/en/latest/examples/resource_constrained_project_scheduling_problem.html
    """

    num_jobs: int  # jobs in RCPSP are tasks in PyJobshop
    num_resources: int
    successors: list[list[int]]
    predecessors: list[list[int]]
    modes: list[Mode]
    capacities: list[int]
    renewable: list[bool]

    @classmethod
    def read_instance(cls, path: str) -> "Instance":
        """
        Reads an instance of the RCPSP from a file.
        Assumes the data is in the PSPLIB format.
        """
        with open(path) as fh:
            lines = fh.readlines()

        prec_idx = lines.index("PRECEDENCE RELATIONS:\n")
        req_idx = lines.index("REQUESTS/DURATIONS:\n")
        avail_idx = lines.index("RESOURCEAVAILABILITIES:\n")

        successors = []

        for line in lines[prec_idx + 2 : req_idx - 1]:
            _, _, _, _, *jobs, _ = re.split(r"\s+", line)
            successors.append([int(x) - 1 for x in jobs])

        predecessors: list[list[int]] = [[] for _ in range(len(successors))]
        for job in range(len(successors)):
            for succ in successors[job]:
                predecessors[succ].append(job)

        mode_data = [
            re.split(r"\s+", line.strip())
            for line in lines[req_idx + 3 : avail_idx - 1]
        ]

        # Prepend the job index to mode data lines if it is missing.
        for idx in range(len(mode_data)):
            if idx == 0:
                continue

            prev = mode_data[idx - 1]
            curr = mode_data[idx]

            if len(curr) < len(prev):
                curr = prev[:1] + curr
                mode_data[idx] = curr

        modes = []
        for mode in mode_data:
            job_idx, _, duration, *consumption = mode
            demands = list(map(int, consumption))
            modes.append(Mode(int(job_idx) - 1, int(duration), demands))

        _, *avail, _ = re.split(r"\s+", lines[avail_idx + 2])
        capacities = list(map(int, avail))

        renewable = [
            x == "R"
            for x in lines[avail_idx + 1].strip().split(" ")
            if x in ["R", "N"]  # R: renewable, N: non-renewable
        ]

        return Instance(
            int(job_idx),
            len(capacities),
            successors,
            predecessors,
            modes,
            capacities,
            renewable,
        )

```

--------------------------------

### solve

Source: https://pyjobshop.org/stable/api/pyjobshop.html

Solves the given problem data instance using a specified solver and configuration.

```APIDOC
## solve

### Description
Solves the given problem data instance.

### Method
`solve`

### Parameters
#### Parameters
- **data** (ProblemData) - Required - The problem data instance.
- **solver** ('ortools' | 'cpoptimizer') - Optional - The solver to use. Either 'ortools' (default) or 'cpoptimizer'.
- **time_limit** (float) - Optional - The time limit for the solver in seconds. Default `float('inf')`.
- **display** (bool) - Optional - Whether to display the solver output. Default `False`.
- **num_workers** (int | None) - Optional - The number of workers to use for parallel solving. If not specified, the default of the selected solver is used, which is typically the number of available CPU cores.
- **initial_solution** (Solution | None) - Optional - An initial solution to start the solver from. Default is no solution.
- **kwargs** - Additional parameters passed to the solver.

### Returns
A Result object containing the best found solution and additional information about the solver run.

### Return type
_Result_

### Raises
**ModuleNotFoundError** – If CP Optimizer is chosen but its dependencies are not installed.
```

--------------------------------

### Solve and Print RCPSP Solution

Source: https://pyjobshop.org/stable/examples/project_scheduling.html

Solves the project scheduling model with a specified time limit and prints the results, including the objective value, lower bound, status, and runtime.

```python
result = model.solve(time_limit=5, display=False)
print(result)
```

--------------------------------

### summary

Source: https://pyjobshop.org/stable/api/pyjobshop.html

Returns a summary of the model, which is the string representation of the ProblemData instance created by the model.

```APIDOC
## summary

### Description
Returns a summary of the model, which is the string representation of the ProblemData instance created by the model.

### Signature
summary() → str
```

--------------------------------

### Solve and Plot Scheduling Problem

Source: https://pyjobshop.org/stable/examples/optional_tasks.html

Solve the defined scheduling problem instance and visualize the resulting task schedule using a Gantt chart. The 'display=False' argument suppresses console output during solving.

```python
result = model.solve(display=False)
```

```python
from pyjobshop.plot import plot_task_gantt

plot_task_gantt(result.best, model.data(), plot_labels=True)
```

--------------------------------

### Clone PyJobShop Repository

Source: https://pyjobshop.org/stable/dev/contributing.html

Clone your forked PyJobShop repository to your local machine. Replace `<your username>` with your GitHub username.

```bash
git clone https://github.com/<your username>/PyJobShop.git
```

--------------------------------

### Define Tasks and Resources for RCPSP

Source: https://pyjobshop.org/stable/examples/project_scheduling.html

Initializes jobs, tasks, and renewable resources for a project scheduling model. This is a prerequisite for defining processing modes and constraints.

```python
jobs = [model.add_job() for _ in range(instance.num_jobs)]
tasks = [model.add_task(job=jobs[idx]) for idx in range(instance.num_jobs)]
resources = [model.add_renewable(capacity) for capacity in instance.capacities]
```

--------------------------------

### Plot Gantt Chart

Source: https://pyjobshop.org/stable/examples/hybrid_flow_shop.html

Generates a Gantt chart visualization of the solution, showing task assignments to machines over time.

```python
plot_machine_gantt(result.best, model.data(), plot_labels=True)

```

--------------------------------

### Plot Gantt Chart of Solution

Source: https://pyjobshop.org/stable/examples/hybrid_flow_shop.html

Visualizes the optimal solution using a Gantt chart. This helps in verifying job sequencing and machine utilization.

```python
from pyjobshop.plot import plot_machine_gantt

data = model.data()
plot_machine_gantt(result.best, model.data(), plot_labels=True)
```

--------------------------------

### Plot Gantt Chart with Labels

Source: https://pyjobshop.org/stable/examples/breaks.html

Generates and displays a Gantt chart for machine schedules, including task labels, using the solved results and model data.

```python
plot_machine_gantt(result.best, model.data(), plot_labels=True)
```

--------------------------------

### Show PyJobShop Version Information

Source: https://pyjobshop.org/stable/setup/getting_help.html

Include the output of this code snippet when reporting bugs to help developers identify version-specific issues. This can be run directly in a Python script or interpreter.

```python
import pyjobshop
pyjobshop.show_versions()
```

--------------------------------

### Plot Machine Gantt Chart

Source: https://pyjobshop.org/stable/examples/flexible_job_shop.html

Visualizes the optimal solution of the FJSP using a machine Gantt chart, displaying task assignments and sequences. Requires the 'plot_machine_gantt' function from PyJobShop.

```python
from pyjobshop.plot import plot_machine_gantt

plot_machine_gantt(result.best, m.data(), plot_labels=True)

```

--------------------------------

### data

Source: https://pyjobshop.org/stable/api/pyjobshop.html

Returns a ProblemData object containing the problem instance.

```APIDOC
## data

### Description
Returns a ProblemData object containing the problem instance.

### Signature
data() → ProblemData
```

--------------------------------

### Plot Gantt Chart of Solution

Source: https://pyjobshop.org/stable/examples/simple_example.html

Generates and displays a Gantt chart visualizing the scheduled tasks on machines. This plot helps in understanding the task assignments, timings, and resource utilization.

```python
from pyjobshop.plot import plot_machine_gantt

plot_machine_gantt(result.best, model.data())
```

--------------------------------

### Plot RCPSP Gantt Chart and Resource Usage

Source: https://pyjobshop.org/stable/examples/project_scheduling.html

Generates a Gantt chart for tasks and plots the usage of each resource over time. Requires matplotlib and PyJobShop plotting utilities.

```python
import matplotlib.pyplot as plt

from pyjobshop.plot import plot_resource_usage, plot_task_gantt

data = model.data()
fig, axes = plt.subplots(
    data.num_resources + 1,
    figsize=(12, 16),
    gridspec_kw={"height_ratios": [6] + [1] * data.num_resources},
)
plt.tight_layout(pad=4)

plot_task_gantt(result.best, model.data(), ax=axes[0])
plot_resource_usage(result.best, model.data(), axes=axes[1:])
```

--------------------------------

### solve

Source: https://pyjobshop.org/stable/api/pyjobshop.html

Solves the scheduling problem defined in the model.

```APIDOC
## solve

### Description
Solves the problem data instance created by the model.

### Signature
`solve() -> Solution`

### Returns
- `Solution`: The solution to the scheduling problem.
```

--------------------------------

### Apply Selection Constraints for Optional Tasks

Source: https://pyjobshop.org/stable/examples/optional_tasks.html

Specify how optional tasks should be selected using PyJobShop's selection constraints. 'select_exactly_one' ensures one of A or C is chosen, while 'select_all_or_none' requires both A and B to be scheduled together or not at all.

```python
model.add_select_exactly_one([A, C])  # Either A or C is scheduled
model.add_select_all_or_none([A, B]);  # A and B are both present or absent
```

--------------------------------

### solve

Source: https://pyjobshop.org/stable/api/pyjobshop.html

Solves the problem data instance created by the model.

```APIDOC
## solve

### Description
Solves the problem data instance created by the model.

### Signature
solve(_solver : 'ortools' | 'cpoptimizer' = `'ortools'`_, _time_limit : float = `float('inf')`_, _display : bool = `True`_, _num_workers : int | None = `None`_, _initial_solution : Solution | None = `None`_, _** kwargs_) → Result

### Parameters
- **solver** ('ortools' | 'cpoptimizer' = `'ortools'`): The solver to use. Either `'ortools'` (default) or `'cpoptimizer'`.
- **time_limit** (float = `float('inf')`): The time limit for the solver in seconds. Default `float('inf')`.
- **display** (bool = `True`): Whether to display the solver output. Default `True`.
- **num_workers** (int | None = `None`): The number of workers to use for parallel solving. If not specified, the default of the selected solver is used, which is typically the number of available CPU cores.
- **initial_solution** (Solution | None = `None`): An initial solution to start the solver from. Default is no solution.
- **kwargs** (**): Additional parameters passed to the solver.

### Returns
Result
```

--------------------------------

### Define Machine Environment

Source: https://pyjobshop.org/stable/examples/hybrid_flow_shop.html

Defines the machines in the HFS environment, grouping them by stage. Each machine is added to the model with a specific name.

```python
machines = [
    [model.add_machine(name=machine_name(k, m)) for m in range(num)]
    for k, num in enumerate(num_machines)
]
```

--------------------------------

### Plot Machine Gantt Chart

Source: https://pyjobshop.org/stable/examples/quick_examples.html

Generates and displays a Gantt chart visualizing the machine schedule from the solved model. This helps in understanding task assignments and timings.

```python
data = model.data()
plot_machine_gantt(result.best, data, plot_labels=True)
```
Tokens:
Raw