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

{job_shop_lib-0.5.1.dist-info → job_shop_lib-1.0.0a1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: job-shop-lib
-Version: 0.5.1
+Version: 1.0.0a1
 Summary: An easy-to-use and modular Python library for the Job Shop Scheduling Problem (JSSP)
 License: MIT
 Author: Pabloo22
@@ -12,7 +12,8 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Provides-Extra: pygraphviz
-Requires-Dist: imageio (>=2,<3)
+Requires-Dist: gymnasium (>=0.29.1,<0.30.0)
+Requires-Dist: imageio[ffmpeg] (>=2.34.1,<3.0.0)
 Requires-Dist: matplotlib (>=3,<4)
 Requires-Dist: networkx (>=3,<4)
 Requires-Dist: numpy (>=1.26.4,<2.0.0)
@@ -23,9 +24,9 @@ Description-Content-Type: text/markdown
 
 <div align="center">
 
-<img src="images/logo_with_transparent_background.png" height="150px">
+<img src="docs/source/images/jslib_minimalist_logo_no_background_fixed.png" height="150px">
 
-<h1>Job Shop Library</h1>
+<h1>JobShopLib</h1>
 
 [![Tests](https://github.com/Pabloo22/job_shop_lib/actions/workflows/tests.yaml/badge.svg)](https://github.com/Pabloo22/job_shop_lib/actions/workflows/tests.yaml)
 ![Python versions](https://img.shields.io/badge/python-3.10%20%7C%203.11%20%7C%203.12-blue)
@@ -34,25 +35,57 @@ Description-Content-Type: text/markdown
 
 </div>
 
-An easy-to-use and modular Python library for the Job Shop Scheduling Problem (JSSP) with a special focus on graph representations.
+JobShopLib is a Python package for creating, solving, and visualizing Job Shop Scheduling Problems (JSSP).
 
-It provides intuitive data structures to represent instances and solutions, as well as solvers and visualization tools.
+It follows a modular design, allowing users to easily extend the library with new solvers, dispatching rules, visualization functions, etc.
 
-See the [this](https://colab.research.google.com/drive/1XV_Rvq1F2ns6DFG8uNj66q_rcowwTZ4H?usp=sharing) Google Colab notebook for a quick start guide! 
+See [this](https://colab.research.google.com/drive/1XV_Rvq1F2ns6DFG8uNj66q_rcowwTZ4H?usp=sharing) Google Colab notebook for a quick start guide! 
 
-## Installation
+## Installation :package:
 
-You can install the library from PyPI:
+<!-- start installation -->
+
+JobShopLib is distributed on [PyPI](https://pypi.org/project/job-shop-lib/) and it supports Python 3.10+.
+
+You can install the latest version using `pip`:
 
 ```bash
 pip install job-shop-lib
 ```
 
-## Quick Start :rocket:
+<!-- 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](docs/source/examples/00-Getting-Started.ipynb) and [How Solutions are Represented](docs/source/examples/01-How-Solutions-are-Represented.ipynb).
+
+- **Benchmark Instances**: Load well-known benchmark instances directly from the library without manual downloading. See [Load Benchmark Instances](docs/source/examples/05-Load-Benchmark-Instances.ipynb).
+
+- **Random Instance Generation**: Create random instances with customizable sizes and properties or augment existing ones. See [`generation`](job_shop_lib/generation) package.
+
+- **Multiple Solvers**:
+  - **Constraint Programming Solver**: OR-Tools' CP-SAT solver. See [Solving the Problem](docs/source/examples/02-Solving-the-Problem.ipynb).
+
+  - **Dispatching Rule Solvers**: Use any of the available dispatching rules or create custom ones. See [Dispatching Rules](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](docs/source/examples/06-Save-Gif.ipynb).
+
+- **Graph Representations**:
+  - **Disjunctive Graphs**: Represent and visualize instances as disjunctive graphs. See [Disjunctive Graph](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](docs/source/examples/07-Agent-Task-Graph.ipynb).
+  - Build your own custom graphs with the `JobShopGraph` class.
+
+- **Gymnasium Environments**: Two environments for solving the problem with Graph Neural Networks (GNNs) or any other method, and Reinforcement Learning (RL). See [SingleJobShopGraphEnv](docs/source/examples/09-SingleJobShopGraphEnv.ipynb) and [MultiJobShopGraphEnv](examples/10-MultiJobShopGraphEnv.ipynb).
+
+<!-- end key features -->
+
+## Some Examples :rocket:
 
 ### Create a Job Shop Instance
 
-You can create a Job Shop Instance by defining the jobs and operations. An operation is defined by the machine(s) it is processed on and the duration (processing time).
+You can create a `JobShopInstance` by defining the jobs and operations. An operation is defined by the machine(s) it is processed on and the duration (processing time).
 
 ```python
 from job_shop_lib import JobShopInstance, Operation
@@ -83,7 +116,7 @@ from job_shop_lib.benchmarking import load_benchmark_instance
 ft06 = load_benchmark_instance("ft06")
 ```
 
-The module `benchmarks` contains functions to load the instances from the file and return them as `JobShopInstance` objects without having to download them
+The module `benchmarking` contains functions to load the instances from the file and return them as `JobShopInstance` objects without having to download them
 manually.
 
 The contributions to this benchmark dataset are as follows:
@@ -115,12 +148,12 @@ https://github.com/thomasWeise/jsspInstancesAndResults
 
 ### Generate a Random Instance
 
-You can also generate a random instance with the `BasicGenerator` class.
+You can also generate a random instance with the `GeneralInstanceGenerator` class.
 
 ```python
-from job_shop_lib.generators import BasicGenerator
+from job_shop_lib.generation import GeneralInstanceGenerator
 
-generator = BasicGenerator(
+generator = GeneralInstanceGenerator(
     duration_range=(5, 10), seed=42, num_jobs=5, num_machines=5
 )
 random_instance = generator.generate()
@@ -129,7 +162,7 @@ random_instance = generator.generate()
 This class can also work as an iterator to generate multiple instances:
 
 ```python
-generator = BasicGenerator(iteration_limit=100, seed=42)
+generator = GeneralInstanceGenerator(iteration_limit=100, seed=42)
 instances = []
 for instance in generator:
     instances.append(instance)
@@ -145,7 +178,7 @@ Every solver is a `Callable` that receives a `JobShopInstance` and returns a `Sc
 ```python
 import matplotlib.pyplot as plt
 
-from job_shop_lib.cp_sat import ORToolsSolver
+from job_shop_lib.constraint_programming import ORToolsSolver
 from job_shop_lib.visualization import plot_gantt_chart
 
 solver = ORToolsSolver(max_time_in_seconds=10)
@@ -154,7 +187,7 @@ ft06_schedule = solver(ft06)
 fig, ax = plot_gantt_chart(ft06_schedule)
 plt.show()
 ```
-![Example Gannt Chart](images/ft06_solution.png)
+![Example Gannt Chart](docs/source/images/ft06_solution.png)
 
 ### Solve an Instance with a Dispatching Rule Solver
 
@@ -190,7 +223,7 @@ create_gif(
 )
 ```
 
-![Example Gif](examples/ft06_optimized.gif)
+![Example Gif](docs/source/examples/output/ft06_optimized.gif)
 
 The dashed red line represents the current time step, which is computed as the earliest time when the next operation can start.
 
@@ -217,11 +250,11 @@ fig = plot_disjunctive_graph(instance)
 plt.show()
 ```
 
-![Example Disjunctive Graph](images/example_disjunctive_graph.png)
+![Example Disjunctive Graph](docs/source/images/example_disjunctive_graph.png)
 
 
-> [!WARNING]
-> This plot function requires having the optional dependency [PyGraphViz](https://pygraphviz.github.io/) installed.
+> [!TIP]
+> Installing the optional dependency [PyGraphViz](https://pygraphviz.github.io/) is recommended.
 
 The `JobShopGraph` class provides easy access to the nodes, for example, to get all the nodes of a specific type:
 
@@ -276,7 +309,7 @@ plt.show()
 ```
 
 <div align="center">
-<img src="examples/agent_task_graph.png" width="300">
+<img src="docs/source/images/agent_task_graph.png" width="300">
 </div>
 <br>
 
@@ -286,43 +319,34 @@ For more details, check the [examples](examples) folder.
 
 ## Installation for development
 
-### With Poetry
+<!-- start installation development -->
 
 1. Clone the repository.
 
-2. Install [poetry](https://python-poetry.org/docs/) if you don't have it already:
-```bash
-pip install poetry==1.7
-```
-3. Create the virtual environment:
 ```bash
-poetry shell
+git clone https://github.com/Pabloo22/job_shop_lib.git
+cd job_shop_lib
 ```
-4. Install dependencies:
+
+2. Install [poetry](https://python-poetry.org/docs/) if you don't have it already:
+
 ```bash
-poetry install --with notebooks --with test --with lint --all-extras
+pip install poetry
 ```
-or equivalently:
+
+3. Install dependencies:
 ```bash
 make poetry_install_all 
 ```
 
-### With PyPI
-
-If you don't want to use Poetry, you can install the library directly from the source code:
-
-```bash
-git clone https://github.com/Pabloo22/job_shop_lib.git
-cd job_shop_lib
-pip install -e .
-```
+<!-- end installation development -->
 
-## License
+## License :scroll:
 
 This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
 
 
-## References
+## References :books:
 
  - J. Adams, E. Balas, and D. Zawack, "The shifting bottleneck procedure
      for job shop scheduling," Management Science, vol. 34, no. 3,

job_shop_lib-1.0.0a1.dist-info/RECORD

@@ -0,0 +1,66 @@
+job_shop_lib/__init__.py,sha256=Ci5ipn-zciO88C5aX5Wx-UN8iBTbpde3dSSg02ZcfwM,597
+job_shop_lib/_base_solver.py,sha256=p17XmtufNc9Y481cqZUT45pEkUmmW1HWG53dfhIBJH8,1363
+job_shop_lib/_job_shop_instance.py,sha256=Q0ml3C36tmcBskBo8MyaZWILJPbdvHjJcvXzD_YfLsU,16475
+job_shop_lib/_operation.py,sha256=8Wj8ZLpxmHw4lJJbLCZoTpFhLaap9MSzwOA5VOJQ-DY,3099
+job_shop_lib/_schedule.py,sha256=2QjhU21pZr7Gl6qEVJ9kXujx-bSrvaTdyZvjGbrQqzs,11193
+job_shop_lib/_scheduled_operation.py,sha256=w7jKhgJ4dQycJ5wSItAd_B9gH5ipcoqy5KxtHFxWTP0,2775
+job_shop_lib/benchmarking/__init__.py,sha256=BYCrJUNr_uk2c0xIbDt07OnUMhQx8Dudkukx3TFWxgw,3271
+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=U6kkk2pHsAgKLOhEjl6R1FFLy-i5_5sxBHaXezMR1tI,9860
+job_shop_lib/dispatching/__init__.py,sha256=QV7qy-y0sSoKp_FslTm7sdqczYzpq0YctzKQ36l0ykg,1510
+job_shop_lib/dispatching/_dispatcher.py,sha256=PCSBpYAF6QPXWrjwkBQXTxOdGdq6Y1Uqw8esQTW05TQ,21357
+job_shop_lib/dispatching/_dispatcher_observer_config.py,sha256=l_lbaw9JJ5icVOmDAzAL6G5t6wG25bQLpRedN1bys8c,1932
+job_shop_lib/dispatching/_factories.py,sha256=UAZLq7d_-puzMYteiAbbhkcW5ucKO-lo3bj8pCCEnOA,4229
+job_shop_lib/dispatching/_history_observer.py,sha256=Vl8rQaxekUeEB-AyNxyC3c76zQakeh-rdri2iDnZvXw,610
+job_shop_lib/dispatching/_ready_operation_filters.py,sha256=q8Xv4kp_2GsvEMC5mlTuJXivAz_b8bbrqo5sXaS3PJU,3110
+job_shop_lib/dispatching/_unscheduled_operations_observer.py,sha256=LNEzqOWqEf6fvtkQrDmDWFEhCfA75OgEtzdomzbxYII,2683
+job_shop_lib/dispatching/feature_observers/__init__.py,sha256=oPrhxw65znMhLugMqUD-1swNi8MufejQbHKiMxtgCU0,1103
+job_shop_lib/dispatching/feature_observers/_composite_feature_observer.py,sha256=SqZ7Th97p1SkmHz2O_xdPCoqiPNwEs71n_iSkCO3FQM,6397
+job_shop_lib/dispatching/feature_observers/_duration_observer.py,sha256=RfWXtxXvS4lakIRWPa1tD0I_UGgb7-h4-tTVvA_x4tA,3490
+job_shop_lib/dispatching/feature_observers/_earliest_start_time_observer.py,sha256=iBkfGxG9-peO8shJKTl2P59YFq63aX_Z4XUvOL6m79g,8912
+job_shop_lib/dispatching/feature_observers/_factory.py,sha256=3nlLDzdf_UJqmNO1Om69ygxj-9mF4kfPBp0rFFUC_a0,2773
+job_shop_lib/dispatching/feature_observers/_feature_observer.py,sha256=N-UhOsw3VbasKucuZlAJyF-k0O7CiwtGFez39xOF66Q,5174
+job_shop_lib/dispatching/feature_observers/_is_completed_observer.py,sha256=_ZSmHt1ZtLNXBipaeSOXwgY14WWN3tIm9sx8WY4-zBw,3448
+job_shop_lib/dispatching/feature_observers/_is_ready_observer.py,sha256=iRr2MsCAglb6dO5fhHKSD7Z2ZHRjYqXK7E8bimAfpOY,1244
+job_shop_lib/dispatching/feature_observers/_is_scheduled_observer.py,sha256=PeLxPVLJX_TP4TG8ViEQFR8WS43wIp6CqyuapM8lIt8,1477
+job_shop_lib/dispatching/feature_observers/_position_in_job_observer.py,sha256=hvztjuajYRx-CnmflWqN4lG06pJelZIRZmarjPK9Afo,1107
+job_shop_lib/dispatching/feature_observers/_remaining_operations_observer.py,sha256=kNvRVbxsx5SI2nMc9ZbmcPd5wDaxiljhkXpk6biV2rI,1442
+job_shop_lib/dispatching/rules/__init__.py,sha256=p1rkqf66L62uvAOM1ZxNV8xHoh7SuYjHi_8ZNBvPIjg,1450
+job_shop_lib/dispatching/rules/_dispatching_rule_factory.py,sha256=5fNpv90fAoR6rcE6NeJOWiB7ir-FVnoONIhHtKJ9H0E,2904
+job_shop_lib/dispatching/rules/_dispatching_rule_solver.py,sha256=r-z3AHwbYNRRnrifoz1gmKASpWqxrUQoxvyfara92KM,5331
+job_shop_lib/dispatching/rules/_dispatching_rules_functions.py,sha256=Wb9fQIfePvCJi4RqJ59UrRSnYufgQw5nQ_Am8M6-JOI,7569
+job_shop_lib/dispatching/rules/_machine_chooser_factory.py,sha256=xsJ8nJwPDBi-sfLJRQF_BBQDbyXDfopD1U-efXffQAE,2331
+job_shop_lib/dispatching/rules/_utils.py,sha256=X8vET2p1D3RyoB9mFfsfRgmilcTmxPssKYyJQ2zEt0Q,4605
+job_shop_lib/exceptions.py,sha256=ARzpoZJCvRIvOesCiqqFSRxkv6w9WwEXx0aBP-l2IKA,1597
+job_shop_lib/generation/__init__.py,sha256=hUqjnE0bEoknuUwFoLUWjBH26qTTCGsJAW4gscAbiQ8,294
+job_shop_lib/generation/_general_instance_generator.py,sha256=8DG70qT2TUTyPp-3Q1DHWo3DhtUvyB4Yo_u0eAa5CIc,7431
+job_shop_lib/generation/_instance_generator.py,sha256=fPcbNoyk0t1JtJpBMiwk3SlyPkWYNkYS7-Vs8qH_eDM,4642
+job_shop_lib/generation/_transformations.py,sha256=FI2qHrETATJUrQP3-RYhZAQ5boyEZ0CF2StDbacBej8,5290
+job_shop_lib/graphs/__init__.py,sha256=Kzw__atE5q_bbLf-vDwqya453RP-CfgV7RlURbdOfSc,1646
+job_shop_lib/graphs/_build_agent_task_graph.py,sha256=ktj-oNLUPmWHfL81EVyaoF4hXClWYfnN7oG2Nn4pOsg,7128
+job_shop_lib/graphs/_build_disjunctive_graph.py,sha256=z1jiuTTaWPJZj-vSZdo064quGx4LEDKjtZIb1FieZW4,3705
+job_shop_lib/graphs/_constants.py,sha256=dqPF--okue5sF70Iv-YR14QKFx4pxPwT2dL1Rh5jylM,374
+job_shop_lib/graphs/_job_shop_graph.py,sha256=QmYj-DptmV3Mca0JHplPa1YPt6D4zDSdIwclKK15Ib0,9938
+job_shop_lib/graphs/_node.py,sha256=FcV92cH1RK6xv8qK3d4QaCRzB-C2kY0MtVeWNgsdi6U,5769
+job_shop_lib/graphs/graph_updaters/__init__.py,sha256=utejVUdKNa3g_6HpfTKanv-9K9sVFlRnqhWpRPGxEHU,358
+job_shop_lib/graphs/graph_updaters/_graph_updater.py,sha256=H8PtBj4gv6y5wQKOstF2CSnLsFjO1YeVHpzvYK3vMRM,2053
+job_shop_lib/graphs/graph_updaters/_residual_graph_updater.py,sha256=kPuBmion70-GAQsyFal8gHylHvZSoBJae9eF8iGOkvA,6097
+job_shop_lib/graphs/graph_updaters/_utils.py,sha256=X5YfwJA1CCgpm1r9C036Gal2CkDh2SSak7wl7TbdjHw,704
+job_shop_lib/reinforcement_learning/__init__.py,sha256=QVFo9e1X-tpanZkGdcCPV_WobQ2EZ_y5uoYSJ36XrQI,957
+job_shop_lib/reinforcement_learning/_multi_job_shop_graph_env.py,sha256=jKMcWYBvz1kwlw00Xe1x9HqhFkMMqlh-Y95NmeBL3-0,15129
+job_shop_lib/reinforcement_learning/_reward_observers.py,sha256=4Kdyn9Jlp_1sBtVr6raF-ZFtcnKxwyCLykfX53TmuhU,2959
+job_shop_lib/reinforcement_learning/_single_job_shop_graph_env.py,sha256=Kbd3N1rKcXm6IHTo99En-oX85vqVobv2bFBCyAht2mE,12949
+job_shop_lib/reinforcement_learning/_types_and_constants.py,sha256=CY849lbv6UXy40KRcMJT3WxvGWrLqcfysu65LPkTfg8,1715
+job_shop_lib/reinforcement_learning/_utils.py,sha256=ilI089Bs8CRlfRV_yH6XH8oypTDtRa7hS-H4iRCC5lU,2497
+job_shop_lib/visualization/__init__.py,sha256=jXC188u5AnSWcO1lRZEzZAPZTXbqlYSPhYc7LMc0itU,1094
+job_shop_lib/visualization/_agent_task_graph.py,sha256=AaBTD_S34WjrsZnL_iMAplR_f67RahZi7x58SOvp-q0,8834
+job_shop_lib/visualization/_disjunctive_graph.py,sha256=pg4KG9BfQbnBPnXYgbyPGe0AuHSmhYqPeqWYAf_spWQ,5905
+job_shop_lib/visualization/_gantt_chart.py,sha256=B9sn4XrEUqgQhRKju-1VUG5R67AZXRu7jbrtA8VcndU,4412
+job_shop_lib/visualization/_gantt_chart_creator.py,sha256=qFhCfk3oC3uF7Mau3lrNhH-34sfHXvkqEXbsDzrIbBk,7721
+job_shop_lib/visualization/_gantt_chart_video_and_gif_creation.py,sha256=XXRLpC05E3zY4SIytdFP2QuxmGA95VohUVmzoFzEt7Q,13206
+job_shop_lib-1.0.0a1.dist-info/LICENSE,sha256=9mggivMGd5taAu3xbmBway-VQZMBzurBGHofFopvUsQ,1069
+job_shop_lib-1.0.0a1.dist-info/METADATA,sha256=h5mdFHRaXbnL7F4lMjGNVE5-TSx35rvAG8SlzX3wWiU,14810
+job_shop_lib-1.0.0a1.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+job_shop_lib-1.0.0a1.dist-info/RECORD,,

job_shop_lib/benchmarking/load_benchmark.py

@@ -1,142 +0,0 @@
-"""Module for loading benchmark instances.
-
-All benchmark instances are stored in a single JSON file. This module provides
-functions to load the instances from the file and return them as
-JobShopInstance objects.
-
-The contributions to this benchmark dataset are as follows:
-
-abz5-9: This subset, comprising five instances, was introduced by Adams et
-    al. (1988).
-ft06, ft10, ft20: These three instances are attributed to the work of
-    Fisher and Thompson, as detailed in their 1963 work.
-la01-40: A collection of forty instances, this group was contributed by
-    Lawrence, as referenced in his 1984 report.
-orb01-10: Ten instances in this category were provided by Applegate and
-    Cook, as seen in their 1991 study.
-swb01-20: This segment, encompassing twenty instances, was contributed by
-    Storer et al., as per their 1992 article.
-yn1-4: Yamada and Nakano are credited with the addition of four instances
-    in this group, as found in their 1992 paper.
-ta01-80: The largest contribution, consisting of eighty instances, was
-    made by Taillard, as documented in his 1993 paper.
-
-The metadata from these instances has been updated using data from:
-
-Thomas Weise. jsspInstancesAndResults. Accessed in January 2024.
-Available at: https://github.com/thomasWeise/jsspInstancesAndResults
-
-It includes the following information:
-    - "optimum" (int | None): The optimal makespan for the instance.
-    - "lower_bound" (int): The lower bound for the makespan. If
-        optimality is known, it is equal to the optimum.
-    - "upper_bound" (int): The upper bound for the makespan. If
-        optimality is known, it is equal to the optimum.
-    - "reference" (str): The paper or source where the instance was first
-        introduced.
-
-References:
-    - 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.
-
-    - J.F. Muth and G.L. Thompson, Industrial scheduling. Englewood Cliffs,
-        NJ: Prentice-Hall, 1963.
-
-    - S. Lawrence, "Resource constrained project scheduling: An experimental
-        investigation of heuristic scheduling techniques (Supplement),"
-        Carnegie-Mellon University, Graduate School of Industrial
-        Administration, Pittsburgh, Pennsylvania, 1984.
-
-    - D. Applegate and W. Cook, "A computational study of job-shop
-        scheduling," ORSA Journal on Computer, vol. 3, no. 2, pp. 149–156,
-        1991.
-
-    - R.H. Storer, S.D. Wu, and R. Vaccari, "New search spaces for
-        sequencing problems with applications to job-shop scheduling,"
-        Management Science, vol. 38, no. 10, pp. 1495–1509, 1992.
-
-    - T. Yamada and R. Nakano, "A genetic algorithm applicable to
-        large-scale job-shop problems," in Proceedings of the Second
-        International Workshop on Parallel Problem Solving from Nature
-        (PPSN'2), Brussels, Belgium, pp. 281–290, 1992.
-
-    - E. Taillard, "Benchmarks for basic scheduling problems," European
-        Journal of Operational Research, vol. 64, no. 2, pp. 278–285, 1993.
-"""
-
-from typing import Any
-
-import functools
-import json
-from importlib import resources
-
-from job_shop_lib import JobShopInstance
-
-
-@functools.cache
-def load_all_benchmark_instances() -> dict[str, JobShopInstance]:
-    """Loads all benchmark instances available.
-
-    Returns:
-        A dictionary containing the names of the benchmark instances as keys
-        and the corresponding JobShopInstance objects as values.
-
-    """
-    benchmark_instances_dict = load_benchmark_json()
-    return {
-        name: load_benchmark_instance(name)
-        for name in benchmark_instances_dict
-    }
-
-
-def load_benchmark_instance(name: str) -> JobShopInstance:
-    """Loads a specific benchmark instance.
-
-    Calls to `load_benchmark_json` to load the benchmark instances from the
-    JSON file. The instance is then loaded from the dictionary using the
-    provided name. Since `load_benchmark_json` is cached, the file is only
-    read once.
-
-    Args:
-        name: The name of the benchmark instance to load. Can be one of the
-            following: "abz5-9", "ft06", "ft10", "ft20", "la01-40", "orb01-10",
-            "swb01-20", "yn1-4", or "ta01-80".
-    """
-    benchmark_dict = load_benchmark_json()[name]
-    return JobShopInstance.from_matrices(
-        duration_matrix=benchmark_dict["duration_matrix"],
-        machines_matrix=benchmark_dict["machines_matrix"],
-        name=name,
-        metadata=benchmark_dict["metadata"],
-    )
-
-
-@functools.cache
-def load_benchmark_json() -> dict[str, dict[str, Any]]:
-    """Loads the raw JSON file containing the benchmark instances.
-
-    Results are cached to avoid reading the file multiple times.
-
-    Each instance is represented as a dictionary with the following keys
-    and values:
-        - "name" (str): The name of the instance.
-        - "duration_matrix" (list[list[int]]): The matrix containing the
-            durations for each operation.
-        - "machines_matrix" (list[list[int]]): The matrix containing the
-            machines for each operation.
-        - "metadata" (dict[str, Any]): A dictionary containing metadata
-            about the instance. The keys are "optimum" (int | None),
-            "lower_bound" (int), "upper_bound" (int),
-            and "reference" (str).
-
-    Returns:
-        The dictionary containing the benchmark instances.
-    """
-    benchmark_file = (
-        resources.files("job_shop_lib.benchmarking")
-        / "benchmark_instances.json"
-    )
-
-    with benchmark_file.open("r", encoding="utf-8") as f:
-        return json.load(f)

job_shop_lib/cp_sat/__init__.py

@@ -1,5 +0,0 @@
-from job_shop_lib.cp_sat.ortools_solver import ORToolsSolver
-
-__all__ = [
-    "ORToolsSolver",
-]

job_shop_lib/dispatching/factories.py

@@ -1,206 +0,0 @@
-"""Contains factory functions for creating dispatching rules, machine choosers,
-and pruning functions for the job shop scheduling problem.
-
-The factory functions create and return the appropriate functions based on the
-specified names or enums.
-"""
-
-from enum import Enum
-
-from collections.abc import Callable, Sequence
-import random
-
-from job_shop_lib import Operation
-from job_shop_lib.dispatching import (
-    shortest_processing_time_rule,
-    first_come_first_served_rule,
-    most_work_remaining_rule,
-    most_operations_remaining_rule,
-    random_operation_rule,
-    Dispatcher,
-    prune_dominated_operations,
-    prune_non_immediate_machines,
-    create_composite_pruning_function,
-)
-
-
-class DispatchingRule(str, Enum):
-    """Enumeration of dispatching rules for the job shop scheduling problem."""
-
-    SHORTEST_PROCESSING_TIME = "shortest_processing_time"
-    FIRST_COME_FIRST_SERVED = "first_come_first_served"
-    MOST_WORK_REMAINING = "most_work_remaining"
-    MOST_OPERATIONS_REMAINING = "most_operations_remaining"
-    RANDOM = "random"
-
-
-class MachineChooser(str, Enum):
-    """Enumeration of machine chooser strategies for the job shop scheduling"""
-
-    FIRST = "first"
-    RANDOM = "random"
-
-
-class PruningFunction(str, Enum):
-    """Enumeration of pruning functions.
-
-    A pruning function is used by the `Dispatcher` class to reduce the
-    amount of available operations to choose from.
-    """
-
-    DOMINATED_OPERATIONS = "dominated_operations"
-    NON_IMMEDIATE_MACHINES = "non_immediate_machines"
-
-
-def dispatching_rule_factory(
-    dispatching_rule: str | DispatchingRule,
-) -> Callable[[Dispatcher], Operation]:
-    """Creates and returns a dispatching rule function based on the specified
-    dispatching rule name.
-
-    The dispatching rule function determines the order in which operations are
-    selected for execution based on certain criteria such as shortest
-    processing time, first come first served, etc.
-
-    Args:
-        dispatching_rule: The name of the dispatching rule to be used.
-            Supported values are 'shortest_processing_time',
-            'first_come_first_served', 'most_work_remaining',
-            and 'random'.
-
-    Returns:
-        A function that takes a Dispatcher instance as input and returns an
-        Operation based on the specified dispatching rule.
-
-    Raises:
-        ValueError: If the dispatching_rule argument is not recognized or is
-            not supported.
-    """
-    dispatching_rules = {
-        DispatchingRule.SHORTEST_PROCESSING_TIME: (
-            shortest_processing_time_rule
-        ),
-        DispatchingRule.FIRST_COME_FIRST_SERVED: first_come_first_served_rule,
-        DispatchingRule.MOST_WORK_REMAINING: most_work_remaining_rule,
-        DispatchingRule.MOST_OPERATIONS_REMAINING: (
-            most_operations_remaining_rule
-        ),
-        DispatchingRule.RANDOM: random_operation_rule,
-    }
-
-    dispatching_rule = dispatching_rule.lower()
-    if dispatching_rule not in dispatching_rules:
-        raise ValueError(
-            f"Dispatching rule {dispatching_rule} not recognized. Available "
-            f"dispatching rules: {', '.join(dispatching_rules)}."
-        )
-
-    return dispatching_rules[dispatching_rule]  # type: ignore[index]
-
-
-def machine_chooser_factory(
-    machine_chooser: str,
-) -> Callable[[Dispatcher, Operation], int]:
-    """Creates and returns a machine chooser function based on the specified
-    machine chooser strategy name.
-
-    The machine chooser function determines which machine an operation should
-    be assigned to for execution. The selection can be based on different
-    strategies such as choosing the first available machine or selecting a
-    machine randomly.
-
-    Args:
-        machine_chooser (str): The name of the machine chooser strategy to be
-            used. Supported values are 'first' and 'random'.
-
-    Returns:
-        A function that takes a Dispatcher instance and an Operation as input
-        and returns the index of the selected machine based on the specified
-        machine chooser strategy.
-
-    Raises:
-        ValueError: If the machine_chooser argument is not recognized or is
-            not supported.
-    """
-    machine_choosers: dict[str, Callable[[Dispatcher, Operation], int]] = {
-        MachineChooser.FIRST: lambda _, operation: operation.machines[0],
-        MachineChooser.RANDOM: lambda _, operation: random.choice(
-            operation.machines
-        ),
-    }
-
-    machine_chooser = machine_chooser.lower()
-    if machine_chooser not in machine_choosers:
-        raise ValueError(
-            f"Machine chooser {machine_chooser} not recognized. Available "
-            f"machine choosers: {', '.join(machine_choosers)}."
-        )
-
-    return machine_choosers[machine_chooser]
-
-
-def composite_pruning_function_factory(
-    pruning_function_names: Sequence[str | PruningFunction],
-) -> Callable[[Dispatcher, list[Operation]], list[Operation]]:
-    """Creates and returns a composite pruning function based on the
-    specified list of pruning strategies.
-
-    The composite pruning function filters out operations based on
-    the specified list of pruning strategies.
-
-    Args:
-        pruning_functions:
-            A list of pruning strategies to be used. Supported values are
-            'dominated_operations' and 'non_immediate_machines'.
-
-    Returns:
-        A function that takes a Dispatcher instance and a list of Operation
-        instances as input and returns a list of Operation instances based on
-        the specified list of pruning strategies.
-
-    Raises:
-        ValueError: If any of the pruning strategies in the list are not
-            recognized or are not supported.
-    """
-
-    pruning_functions = [
-        pruning_function_factory(name) for name in pruning_function_names
-    ]
-    return create_composite_pruning_function(pruning_functions)
-
-
-def pruning_function_factory(
-    pruning_function_name: str | PruningFunction,
-) -> Callable[[Dispatcher, list[Operation]], list[Operation]]:
-    """Creates and returns a pruning function based on the specified
-    pruning strategy name.
-
-    The pruning function filters out operations based on certain
-    criteria such as dominated operations, non-immediate machines, etc.
-
-    Args:
-        pruning_function:
-            The name of the pruning function to be used. Supported values are
-            'dominated_operations' and 'non_immediate_machines'.
-
-    Returns:
-        A function that takes a Dispatcher instance and a list of Operation
-        instances as input and returns a list of Operation instances based on
-        the specified pruning function.
-
-    Raises:
-        ValueError: If the pruning_function argument is not recognized or is
-            not supported.
-    """
-    pruning_strategies = {
-        PruningFunction.DOMINATED_OPERATIONS: prune_dominated_operations,
-        PruningFunction.NON_IMMEDIATE_MACHINES: prune_non_immediate_machines,
-    }
-
-    if pruning_function_name not in pruning_strategies:
-        raise ValueError(
-            f"Unsupported pruning function '{pruning_function_name}'. "
-            f"Supported values are {', '.join(pruning_strategies.keys())}."
-        )
-
-    return pruning_strategies[pruning_function_name]  # type: ignore[index]