job-shop-lib 0.5.0__py3-none-any.whl → 1.0.0__py3-none-any.whl

job_shop_lib-1.0.0.dist-info/RECORD

@@ -0,0 +1,73 @@
+job_shop_lib/__init__.py,sha256=o3TWKp2_4n2WquWkaCsMo32Dd3TkXRRaPIEKpvgiI2k,639
+job_shop_lib/_base_solver.py,sha256=p17XmtufNc9Y481cqZUT45pEkUmmW1HWG53dfhIBJH8,1363
+job_shop_lib/_job_shop_instance.py,sha256=hNQGSJj0rEQpS-YhzwWmM6QzCWp6r--89jkghSgLvUs,18380
+job_shop_lib/_operation.py,sha256=DrnlIrmnKFT5lzMvqCMszF18WcK77AJTRDO5wWrmm7s,4273
+job_shop_lib/_schedule.py,sha256=-RdCtTTj-SdNLFucmSVnrCbjZLcBZ4yfhRBdATjAaW8,11292
+job_shop_lib/_scheduled_operation.py,sha256=czrGr87EOTlO2NPolIN5CDigeiCzvQEyra5IZPwSFZc,2801
+job_shop_lib/benchmarking/__init__.py,sha256=BYCrJUNr_uk2c0xIbDt07OnUMhQx8Dudkukx3TFWxgw,3271
+job_shop_lib/benchmarking/_load_benchmark.py,sha256=Jb6HYGKkub-3uU3l3NreRPE0PU6f0n8G9Mih5vMImOI,2936
+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=vz_Kg_CmvZ13yGgqi-hZuFkosJR1v449xNaAZV3PhsE,10501
+job_shop_lib/dispatching/__init__.py,sha256=SXVd0Zh6xTp-lNT7c463pii3l168NCZYf-5uOwBI1Fc,1770
+job_shop_lib/dispatching/_dispatcher.py,sha256=oC-1h6p83qzumynJWMzsrbsudM1tt9AebAufKEjygRI,22039
+job_shop_lib/dispatching/_dispatcher_observer_config.py,sha256=RaUkLxYCHG8Tx2tPgFyOBa8FAcbREZdKuTyLsyaYvhA,2473
+job_shop_lib/dispatching/_factories.py,sha256=NzpUdxHDU_aVjHBScu8HVhSKZnTKYItHcUFS4mUp4KM,4723
+job_shop_lib/dispatching/_history_observer.py,sha256=dixJe83quzGNwG0u0k2uES7GsLw0zWCjX0MOUD4VTRU,634
+job_shop_lib/dispatching/_optimal_operations_observer.py,sha256=HS933mn2VlwgE7plSsth94RGlbEzfskF6TNyOM7rQrY,4246
+job_shop_lib/dispatching/_ready_operation_filters.py,sha256=vzo9vfijhc-Y75GrBpxuoYKaUuSL7-picD230PdhwuI,5778
+job_shop_lib/dispatching/_unscheduled_operations_observer.py,sha256=3E0ePesDdWdNs6520znnOBW3eiegJj5bZg9Tmb0xoSA,2705
+job_shop_lib/dispatching/feature_observers/__init__.py,sha256=EuJLvSpJpoXUK8A4UuC2k6Mpa293ZR3oCnnvYivIBtU,2240
+job_shop_lib/dispatching/feature_observers/_composite_feature_observer.py,sha256=QqgadgmHjNTPOKs4wVamnPjqls9kKOH40o3N0lZZ4aw,8026
+job_shop_lib/dispatching/feature_observers/_duration_observer.py,sha256=fbkUIVScF1iNjdVCYr1ImQm53TfahvVnGXhsRAsgdzY,4129
+job_shop_lib/dispatching/feature_observers/_earliest_start_time_observer.py,sha256=W5Tr81Kme8N-m85jmX7yVc65_xlwNQBvVjnjlL-aq7w,11493
+job_shop_lib/dispatching/feature_observers/_factory.py,sha256=RWrRdEDBv_0vpJNHD67_Qjov2_72yS5d7tXJiWuyobQ,3321
+job_shop_lib/dispatching/feature_observers/_feature_observer.py,sha256=nxDPYoVu5nAeDuXqdkA-H8slHRSt47JyHDERNachDCA,8693
+job_shop_lib/dispatching/feature_observers/_is_completed_observer.py,sha256=8nmdnlPQfuudipWcxPhUPbQvlIHLmnzoeQyWkNzB-J8,3642
+job_shop_lib/dispatching/feature_observers/_is_ready_observer.py,sha256=aP5CpwmCWP4w8J69qAC7QwGRQGMlfNbM31n-BRu92DA,1289
+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=g3PGvMLMa3WMgNhGSW3S_xkHqoHpW8hr_9JqOfR7Xrk,2140
+job_shop_lib/dispatching/rules/_dispatching_rule_factory.py,sha256=0v7IcSQadvlX6tRy86Z55ruwIY70H9q9E46tdazjtkU,2942
+job_shop_lib/dispatching/rules/_dispatching_rule_solver.py,sha256=9-UE0HiHCeFXFGqB85cSfduLCEm5k5bJkmIujP-_irg,7321
+job_shop_lib/dispatching/rules/_dispatching_rules_functions.py,sha256=wfBdiKqEQQ8C5Gg_mrWWSuWncPwUkFacjeAQ8D4n9Wc,7648
+job_shop_lib/dispatching/rules/_machine_chooser_factory.py,sha256=AtYJGuvKlc3T4Y5NCGxgjQ-np3d1aeADAZ3r68No_WA,2383
+job_shop_lib/dispatching/rules/_utils.py,sha256=DFDpRoHb56Rtn01vfN69Bq0X3F8P1EtM6trHx9aXg3U,4643
+job_shop_lib/exceptions.py,sha256=ARzpoZJCvRIvOesCiqqFSRxkv6w9WwEXx0aBP-l2IKA,1597
+job_shop_lib/generation/__init__.py,sha256=tgMVhnh62lkwGKywvingFD9SLhc-vERKiWsS-41qQKA,605
+job_shop_lib/generation/_general_instance_generator.py,sha256=e-NDkH-NoCwa14oADj6n_I7BX5xWWVVzRLvb4rpJ92w,6374
+job_shop_lib/generation/_instance_generator.py,sha256=VV0OKX4JgFq3I1EY6s3LrOdPjM3v4lH6S1hkUebTkFQ,4615
+job_shop_lib/generation/_transformations.py,sha256=X-hTAJVIHZ3bmF1rqS0zCit8r5SGpHpV8Fcl92fejow,5336
+job_shop_lib/generation/_utils.py,sha256=cBhGILE0FE3TqvWoHqpaFEffO8D2fb869pF-BdMlYsg,3617
+job_shop_lib/graphs/__init__.py,sha256=anR7zg1eHf1JweRGFbrwE26MeFbzQYBEHTfy6osalyU,1897
+job_shop_lib/graphs/_build_disjunctive_graph.py,sha256=UbUYdeQaaeEqLchcKJGHEFGl4wElfGLb1o_R-u8wqnA,5120
+job_shop_lib/graphs/_build_resource_task_graphs.py,sha256=mWg8C-62aqvAwIKsreAHLYIq-VOc0q7BEnOnlUrywb8,6961
+job_shop_lib/graphs/_constants.py,sha256=K-GeVvh_DTWpo1KOX1clmxWS_pkUJbq19yOBmrCVIxI,1086
+job_shop_lib/graphs/_job_shop_graph.py,sha256=TdpUNLv9FBuosPrhLrhQl75u_kwRX0vygKFknLT6pJY,11480
+job_shop_lib/graphs/_node.py,sha256=9TFH8C1D44W1IvOIG8MucLNQyLzasyBXVkMZTJU4rso,6075
+job_shop_lib/graphs/graph_updaters/__init__.py,sha256=VpFsGPzm4VQiXE0vBeAL5h3jXxiR7Hap0F2BPQwRTjQ,639
+job_shop_lib/graphs/graph_updaters/_disjunctive_graph_updater.py,sha256=-t0T8W-Jz9TJQR9-ljPkcDsDC4CwJAfs2nUF3zjEtuw,4369
+job_shop_lib/graphs/graph_updaters/_graph_updater.py,sha256=j1f7iWsa62GVszK2BPaMxnKBCEGWa9owm8g4VWUje8w,1967
+job_shop_lib/graphs/graph_updaters/_residual_graph_updater.py,sha256=SyQJXIJvXijO51AzPz7YbCPZZK8d8JHE63LFX_F95Gc,6102
+job_shop_lib/graphs/graph_updaters/_utils.py,sha256=sdw2Vo75P9c6Fy-YBlfgpXb9gPwHUluTB1E-9WINm_g,730
+job_shop_lib/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+job_shop_lib/reinforcement_learning/__init__.py,sha256=CZOnKqyjfcPXOh7ZLy-RvNbIAi1SnUs0WGC1fHo09pE,1512
+job_shop_lib/reinforcement_learning/_multi_job_shop_graph_env.py,sha256=fwgKveAoNtO-uV4NvmfSG_ZeDPY0W2KZYcsFNHY8QY4,15749
+job_shop_lib/reinforcement_learning/_resource_task_graph_observation.py,sha256=4H53fKMgxPWqFVF5WczomEcrFdq7abBgHnOYJ1m6D1c,12768
+job_shop_lib/reinforcement_learning/_reward_observers.py,sha256=iWHccnujeAKyTQn2ilQ4BhcEccoSTyJqQ5yOiP5GG_Y,2984
+job_shop_lib/reinforcement_learning/_single_job_shop_graph_env.py,sha256=FCghBwfKZZg2VFJdV0ihzRJBTwMuivB-zhf9qM2OZq8,16803
+job_shop_lib/reinforcement_learning/_types_and_constants.py,sha256=6FpuQkZLV2H8_dXmax49OTgAw7dWQcUEWVWWdMLR7bs,1752
+job_shop_lib/reinforcement_learning/_utils.py,sha256=0jM7qPCxYbURKAQlCLt4Ah1OrmdGUUhxhOsszTdt2Zk,6049
+job_shop_lib/visualization/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+job_shop_lib/visualization/gantt/__init__.py,sha256=HGXwRgDuMAldqU0JBdiZCd5e79XBz1r96qHeDVlzE54,1145
+job_shop_lib/visualization/gantt/_gantt_chart_creator.py,sha256=LTsVhpB1Fb_2o08HRZPPXSekwzR7fyTSC6h549XMqhU,8638
+job_shop_lib/visualization/gantt/_gantt_chart_video_and_gif_creation.py,sha256=KeMiTBOtJKchnKGD4av8_3x3S5h437pRymc2q2knbNc,14617
+job_shop_lib/visualization/gantt/_plot_gantt_chart.py,sha256=9-NSSNsVcW8gYLZtAuFeYURqi8cHNkVYufosKtbKFOI,6881
+job_shop_lib/visualization/graphs/__init__.py,sha256=282hZFg07EyQu4HVt4GzFfYnY6ZF376IMjnWZ5eg0ZQ,611
+job_shop_lib/visualization/graphs/_plot_disjunctive_graph.py,sha256=wF2zaPsvg1TszP_2n3ialTTUS7IkCqu9y79kU0bGbpw,15982
+job_shop_lib/visualization/graphs/_plot_resource_task_graph.py,sha256=RgJqHS5hJh3KkyaLbtpG_bER981BFRwGpflz7I7gS64,13271
+job_shop_lib-1.0.0.dist-info/LICENSE,sha256=9mggivMGd5taAu3xbmBway-VQZMBzurBGHofFopvUsQ,1069
+job_shop_lib-1.0.0.dist-info/METADATA,sha256=PHGguy8Da24M4rqmxcAxkGmct54ZFVgsw5NXEBm-pAw,16110
+job_shop_lib-1.0.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+job_shop_lib-1.0.0.dist-info/RECORD,,

{job_shop_lib-0.5.0.dist-info → job_shop_lib-1.0.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.8.1
+Generator: poetry-core 1.9.0
 Root-Is-Purelib: true
 Tag: py3-none-any

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/dispatching_rule_solver.py

@@ -1,119 +0,0 @@
-"""Home of the `DispatchingRuleSolver` class."""
-
-from collections.abc import Callable
-
-from job_shop_lib import JobShopInstance, Schedule, Operation, BaseSolver
-from job_shop_lib.dispatching import (
-    dispatching_rule_factory,
-    machine_chooser_factory,
-    pruning_function_factory,
-    DispatchingRule,
-    MachineChooser,
-    Dispatcher,
-    PruningFunction,
-)
-
-
-class DispatchingRuleSolver(BaseSolver):
-    """Solves a job shop instance using a dispatching rule.
-
-    Attributes:
-        dispatching_rule:
-            The dispatching rule to use. It is a callable that takes a
-            dispatcher and returns the operation to be dispatched next.
-        machine_chooser:
-            Used to choose the machine where the operation will be dispatched
-            to. It is only used if the operation can be dispatched to multiple
-            machines.
-        pruning_function:
-            The pruning function to use. It is used to initialize the
-            dispatcher object internally when calling the solve method.
-    """
-
-    def __init__(
-        self,
-        dispatching_rule: (
-            str | Callable[[Dispatcher], Operation]
-        ) = DispatchingRule.MOST_WORK_REMAINING,
-        machine_chooser: (
-            str | Callable[[Dispatcher, Operation], int]
-        ) = MachineChooser.FIRST,
-        pruning_function: (
-            str
-            | Callable[[Dispatcher, list[Operation]], list[Operation]]
-            | None
-        ) = PruningFunction.DOMINATED_OPERATIONS,
-    ):
-        """Initializes the solver with the given dispatching rule, machine
-        chooser and pruning function.
-
-        Args:
-            dispatching_rule:
-                The dispatching rule to use. It can be a string with the name
-                of the dispatching rule, a DispatchingRule enum member, or a
-                callable that takes a dispatcher and returns the operation to
-                be dispatched next.
-            machine_chooser:
-                The machine chooser to use. It can be a string with the name
-                of the machine chooser, a MachineChooser enum member, or a
-                callable that takes a dispatcher and an operation and returns
-                the machine id where the operation will be dispatched.
-            pruning_function:
-                The pruning function to use. It can be a string with the name
-                of the pruning function, a PruningFunction enum member, or a
-                callable that takes a dispatcher and a list of operations and
-                returns a list of operations that should be considered for
-                dispatching.
-        """
-        if isinstance(dispatching_rule, str):
-            dispatching_rule = dispatching_rule_factory(dispatching_rule)
-        if isinstance(machine_chooser, str):
-            machine_chooser = machine_chooser_factory(machine_chooser)
-        if isinstance(pruning_function, str):
-            pruning_function = pruning_function_factory(pruning_function)
-
-        self.dispatching_rule = dispatching_rule
-        self.machine_chooser = machine_chooser
-        self.pruning_function = pruning_function
-
-    def solve(
-        self, instance: JobShopInstance, dispatcher: Dispatcher | None = None
-    ) -> Schedule:
-        """Returns a schedule for the given job shop instance using the
-        dispatching rule algorithm."""
-        if dispatcher is None:
-            dispatcher = Dispatcher(
-                instance, pruning_function=self.pruning_function
-            )
-        while not dispatcher.schedule.is_complete():
-            self.step(dispatcher)
-
-        return dispatcher.schedule
-
-    def step(self, dispatcher: Dispatcher) -> None:
-        """Executes one step of the dispatching rule algorithm.
-
-        Args:
-            dispatcher:
-                The dispatcher object that will be used to dispatch the
-                operations.
-        """
-        selected_operation = self.dispatching_rule(dispatcher)
-        machine_id = self.machine_chooser(dispatcher, selected_operation)
-        dispatcher.dispatch(selected_operation, machine_id)
-
-
-if __name__ == "__main__":
-    import time
-    from job_shop_lib.benchmarking import load_benchmark_instance
-
-    ta_instances = []
-    for i in range(1, 81):
-        ta_instances.append(load_benchmark_instance(f"ta{i:02d}"))
-    solver = DispatchingRuleSolver(dispatching_rule="most_work_remaining")
-    # cProfile.run("for instance in ta_instances: solver.solve(instance)")
-    start = time.perf_counter()
-    for instance_ in ta_instances:
-        solver.solve(instance_)
-    end = time.perf_counter()
-    print(f"Elapsed time: {end - start:.2f} seconds.")

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]

job_shop_lib/dispatching/feature_observers/composite_feature_observer.py

@@ -1,87 +0,0 @@
-"""Home of the `CompositeFeatureObserver` class."""
-
-from collections import defaultdict
-import numpy as np
-import pandas as pd
-
-from job_shop_lib.dispatching import Dispatcher
-from job_shop_lib.dispatching.feature_observers import (
-    FeatureObserver,
-    FeatureType,
-)
-
-
-class CompositeFeatureObserver(FeatureObserver):
-    """Aggregates features from other FeatureObserver instances subscribed to
-    the same `Dispatcher` by concatenating their feature matrices along the
-    first axis (horizontal concatenation).
-
-    Attributes:
-        feature_observers:
-            List of `FeatureObserver` instances to aggregate features from.
-        column_names:
-            Dictionary mapping `FeatureType` to a list of column names for the
-            corresponding feature matrix. Column names are generated based on
-            the class name of the `FeatureObserver` instance that produced the
-            feature.
-    """
-
-    def __init__(
-        self,
-        dispatcher: Dispatcher,
-        feature_observers: list[FeatureObserver] | None = None,
-        subscribe: bool = True,
-    ):
-        if feature_observers is None:
-            feature_observers = [
-                observer
-                for observer in dispatcher.subscribers
-                if isinstance(observer, FeatureObserver)
-            ]
-        self.feature_observers = feature_observers
-        self.column_names: dict[FeatureType, list[str]] = defaultdict(list)
-        super().__init__(dispatcher, subscribe=subscribe)
-        self._set_column_names()
-
-    @property
-    def features_as_dataframe(self) -> dict[FeatureType, pd.DataFrame]:
-        """Returns the features as a dictionary of `pd.DataFrame` instances."""
-        return {
-            feature_type: pd.DataFrame(
-                feature_matrix, columns=self.column_names[feature_type]
-            )
-            for feature_type, feature_matrix in self.features.items()
-        }
-
-    def initialize_features(self):
-        features: dict[FeatureType, list[np.ndarray]] = defaultdict(list)
-        for observer in self.feature_observers:
-            for feature_type, feature_matrix in observer.features.items():
-                features[feature_type].append(feature_matrix)
-
-        self.features = {
-            feature_type: np.concatenate(features, axis=1)
-            for feature_type, features in features.items()
-        }
-
-    def _set_column_names(self):
-        for observer in self.feature_observers:
-            for feature_type, feature_matrix in observer.features.items():
-                feature_name = observer.__class__.__name__.replace(
-                    "Observer", ""
-                )
-                if feature_matrix.shape[1] > 1:
-                    self.column_names[feature_type] += [
-                        f"{feature_name}_{i}"
-                        for i in range(feature_matrix.shape[1])
-                    ]
-                else:
-                    self.column_names[feature_type].append(feature_name)
-
-    def __str__(self):
-        out = [f"{self.__class__.__name__}:"]
-        out.append("-" * (len(out[0]) - 1))
-        for feature_type, dataframe in self.features_as_dataframe.items():
-            out.append(f"{feature_type.value}:")
-            out.append(dataframe.to_string())
-        return "\n".join(out)