nextroute 1.8.0.dev24__cp312-cp312-macosx_13_0_x86_64.whl → 1.12.3__cp312-cp312-macosx_13_0_x86_64.whl

nextroute/__about__.py

@@ -1,3 +1,3 @@
 # © 2019-present nextmv.io inc
 
-__version__ = "v1.8.0.dev24"
+__version__ = "v1.12.3"

nextroute/__init__.py

@@ -9,10 +9,8 @@ to it.
 """
 
 from .__about__ import __version__
-from .options import DisableFormatOptions as DisableFormatOptions
-from .options import FormatOptions as FormatOptions
 from .options import Options as Options
-from .options import ParallelSolveOptions as ParallelSolveOptions
+from .options import Verbosity as Verbosity
 from .solve import solve as solve
 from .version import nextroute_version as nextroute_version
 

nextroute/check/__init__.py

@@ -19,8 +19,6 @@ solution. If the check is invoked on a solution, it is executed on the
 unplanned plan units of the solution.
 """
 
-from .options import Options as Options
-from .options import Verbosity as Verbosity
 from .schema import Objective as Objective
 from .schema import ObjectiveTerm as ObjectiveTerm
 from .schema import Output as Output

nextroute/options.py

@@ -5,69 +5,181 @@ Options for working with the Nextroute engine.
 """
 
 import json
+from enum import Enum
 from typing import Any, Dict, List
 
 from pydantic import Field
 
 from nextroute.base_model import BaseModel
-from nextroute.check.options import Options as CheckOptions
-from nextroute.factory.options import Options as FactoryOptions
 
+# Arguments that require a duration suffix.
 _DURATIONS_ARGS = [
     "-check.duration",
     "-solve.duration",
+    "-solve.plateau.duration",
+    "-solve.plateau.delay",
 ]
 
+# Arguments that require a string enum.
+_STR_ENUM_ARGS = [
+    "CHECK_VERBOSITY",
+]
+
+
+class Verbosity(str, Enum):
+    """Format of an `Input`."""
 
-class ParallelSolveOptions(BaseModel):
-    """Options for the parallel solver."""
+    OFF = "off"
+    """The check engine is not run."""
+    LOW = "low"
+    """Low verbosity for the check engine."""
+    MEDIUM = "medium"
+    """Medium verbosity for the check engine."""
+    HIGH = "high"
+    """High verbosity for the check engine."""
 
-    iterations: int = -1
+
+class Options(BaseModel):
+    """Options for using Nextroute."""
+
+    CHECK_DURATION: float = 30
+    """Maximum duration of the check, in seconds."""
+    CHECK_VERBOSITY: Verbosity = Verbosity.OFF
+    """Verbosity of the check engine."""
+    FORMAT_DISABLE_PROGRESSION: bool = False
+    """Whether to disable the progression series."""
+    MODEL_CONSTRAINTS_DISABLE_ATTRIBUTES: bool = False
+    """Ignore the compatibility attributes constraint."""
+    MODEL_CONSTRAINTS_DISABLE_CAPACITIES: List[str] = Field(default_factory=list)
+    """Ignore the capacity constraint for the given resource names."""
+    MODEL_CONSTRAINTS_DISABLE_CAPACITY: bool = False
+    """Ignore the capacity constraint for all resources."""
+    MODEL_CONSTRAINTS_DISABLE_DISTANCELIMIT: bool = False
+    """Ignore the distance limit constraint."""
+    MODEL_CONSTRAINTS_DISABLE_GROUPS: bool = False
+    """Ignore the groups constraint."""
+    MODEL_CONSTRAINTS_DISABLE_MAXIMUMDURATION: bool = False
+    """Ignore the maximum duration constraint."""
+    MODEL_CONSTRAINTS_DISABLE_MAXIMUMSTOPS: bool = False
+    """Ignore the maximum stops constraint."""
+    MODEL_CONSTRAINTS_DISABLE_MAXIMUMWAITSTOP: bool = False
+    """Ignore the maximum stop wait constraint."""
+    MODEL_CONSTRAINTS_DISABLE_MAXIMUMWAITVEHICLE: bool = False
+    """Ignore the maximum vehicle wait constraint."""
+    MODEL_CONSTRAINTS_DISABLE_MIXINGITEMS: bool = False
+    """Ignore the do not mix items constraint."""
+    MODEL_CONSTRAINTS_DISABLE_PRECEDENCE: bool = False
+    """Ignore the precedence (pickups & deliveries) constraint."""
+    MODEL_CONSTRAINTS_DISABLE_STARTTIMEWINDOWS: bool = False
+    """Ignore the start time windows constraint."""
+    MODEL_CONSTRAINTS_DISABLE_VEHICLEENDTIME: bool = False
+    """Ignore the vehicle end time constraint."""
+    MODEL_CONSTRAINTS_DISABLE_VEHICLESTARTTIME: bool = False
+    """Ignore the vehicle start time constraint."""
+    MODEL_CONSTRAINTS_ENABLE_CLUSTER: bool = False
+    """Enable the cluster constraint."""
+    MODEL_OBJECTIVES_CAPACITIES: str = ""
+    """
+    Capacity objective, provide triple for each resource
+    `name=default;factor=1.0;offset=0.0`.
+    """
+    MODEL_OBJECTIVES_CLUSTER: float = 0.0
+    """Factor to weigh the cluster objective."""
+    MODEL_OBJECTIVES_DISTANCE: float = 0.0
+    """Factor to weigh the distance objective."""
+    MODEL_OBJECTIVES_EARLYARRIVALPENALTY: float = 1.0
+    """Factor to weigh the early arrival objective."""
+    MODEL_OBJECTIVES_LATEARRIVALPENALTY: float = 1.0
+    """Factor to weigh the late arrival objective."""
+    MODEL_OBJECTIVES_MINSTOPS: float = 1.0
+    """Factor to weigh the min stops objective."""
+    MODEL_OBJECTIVES_STOPBALANCE: float = 0.0
+    """Factor to weigh the stop balance objective."""
+    MODEL_OBJECTIVES_TRAVELDURATION: float = 0.0
+    """Factor to weigh the travel duration objective."""
+    MODEL_OBJECTIVES_UNPLANNEDPENALTY: float = 1.0
+    """Factor to weigh the unplanned objective."""
+    MODEL_OBJECTIVES_VEHICLEACTIVATIONPENALTY: float = 1.0
+    """Factor to weigh the vehicle activation objective."""
+    MODEL_OBJECTIVES_VEHICLESDURATION: float = 1.0
+    """Factor to weigh the vehicles duration objective."""
+    MODEL_PROPERTIES_DISABLE_DURATIONGROUPS: bool = False
+    """Ignore the durations groups of stops."""
+    MODEL_PROPERTIES_DISABLE_DURATIONS: bool = False
+    """Ignore the durations of stops."""
+    MODEL_PROPERTIES_DISABLE_INITIALSOLUTION: bool = False
+    """Ignore the initial solution."""
+    MODEL_PROPERTIES_DISABLE_STOPDURATIONMULTIPLIERS: bool = False
+    """Ignore the stop duration multipliers defined on vehicles."""
+    MODEL_PROPERTIES_MAXIMUMTIMEHORIZON: int = 15552000
+    """Maximum time horizon for the model in seconds."""
+    MODEL_VALIDATE_DISABLE_RESOURCES: bool = False
+    """Disable the resources validation."""
+    MODEL_VALIDATE_DISABLE_STARTTIME: bool = False
+    """Disable the start time validation."""
+    MODEL_VALIDATE_ENABLE_MATRIX: bool = False
+    """Enable matrix validation."""
+    MODEL_VALIDATE_ENABLE_MATRIXASYMMETRYTOLERANCE: int = 20
+    """Percentage of acceptable matrix asymmetry, requires matrix validation enabled."""
+    SOLVE_DURATION: float = 5
+    """Maximum duration, in seconds, of the solver."""
+    SOLVE_ITERATIONS: int = -1
     """
     Maximum number of iterations, -1 assumes no limit; iterations are counted
     after start solutions are generated.
     """
-    duration: float = 5
-    """Maximum duration, in seconds, of the solver."""
-    parallel_runs: int = -1
+    SOLVE_PARALLELRUNS: int = -1
     """
     Maximum number of parallel runs, -1 results in using all available
     resources.
     """
-    start_solutions: int = -1
+    SOLVE_PLATEAU_DELAY: float = 0.0
+    """Delay before starting to monitor for a plateau."""
+    SOLVE_PLATEAU_ABSOLUTETHRESHOLD: float = -1
+    """Absolute threshold for significant improvement."""
+    SOLVE_PLATEAU_DURATION: float = 0.0
+    """Maximum duration, in seconds, without (significant) improvement."""
+    SOLVE_PLATEAU_ITERATIONS: int = 0
+    """Maximum number of iterations without (significant) improvement."""
+    SOLVE_PLATEAU_RELATIVETHRESHOLD: float = 0.0
+    """Relative threshold for significant improvement."""
+    SOLVE_RUNDETERMINISTICALLY: bool = False
+    """Run the parallel solver deterministically."""
+    SOLVE_SOLVER_PLANGROUPSIZE_DELTA: int = 0
+    """Delta for the plan group size parameter."""
+    SOLVE_SOLVER_PLANGROUPSIZE_DELTAAFTERITERATIONS: int = 1000000000
+    """Delta after each iteration for the plan group size parameter."""
+    SOLVE_SOLVER_PLANGROUPSIZE_MAXVALUE: int = 2
+    """Maximum value for the plan group size parameter."""
+    SOLVE_SOLVER_PLANGROUPSIZE_MINVALUE: int = 2
+    """Minimum value for the plan group size parameter."""
+    SOLVE_SOLVER_PLANGROUPSIZE_SNAPBACKAFTERIMPROVEMENT: bool = True
+    """Snap back to start value after improvement of best solution for the plan group size parameter."""
+    SOLVE_SOLVER_PLANGROUPSIZE_STARTVALUE: int = 2
+    """Start value for the plan group size parameter."""
+    SOLVE_SOLVER_PLANGROUPSIZE_ZIGZAG: bool = True
+    """Zigzag between min and max value like a jig saw for the plan group size parameter."""
+    SOLVE_SOLVER_UNPLANUNITS_DELTA: int = 2
+    """Delta for the unplan units parameter."""
+    SOLVE_SOLVER_UNPLANUNITS_DELTAAFTERITERATIONS: int = 125
+    """Delta after each iteration for the unplan units parameter."""
+    SOLVE_SOLVER_UNPLANUNITS_MAXVALUE: int = -1
+    """Maximum value for the unplan units parameter."""
+    SOLVE_SOLVER_UNPLANUNITS_MINVALUE: int = 2
+    """Minimum value for the unplan units parameter."""
+    SOLVE_SOLVER_UNPLANUNITS_SNAPBACKAFTERIMPROVEMENT: bool = True
+    """Snap back to start value after improvement of best solution for the unplan units parameter."""
+    SOLVE_SOLVER_UNPLANUNITS_STARTVALUE: int = 2
+    """Start value for the unplan units parameter."""
+    SOLVE_SOLVER_UNPLANUNITS_ZIGZAG: bool = True
+    """Zigzag between min and max value like a jig saw for the unplan units parameter."""
+    SOLVE_SOLVER_UNPLANWEIGHTS: str = "Vehicle:3,Island:1,Location:293"
+    """Unplan heuristic weights parameter."""
+    SOLVE_STARTSOLUTIONS: int = -1
     """
     Number of solutions to generate on top of those passed in; one solution
     generated with sweep algorithm, the rest generated randomly.
     """
-    run_deterministically: bool = False
-    """Run the parallel solver deterministically."""
-
-
-class DisableFormatOptions(BaseModel):
-    """Options for disabling/enabling the progression series."""
-
-    progression: bool = False
-    """Whether to disable the progression series."""
-
-
-class FormatOptions(BaseModel):
-    """Options for formatting the output of the solver."""
-
-    disable: DisableFormatOptions = Field(default_factory=DisableFormatOptions)
-    """Options for disabling/enabling the progression series."""
-
-
-class Options(BaseModel):
-    """Options for using Nextroute."""
-
-    check: CheckOptions = Field(default_factory=CheckOptions)
-    """Options for enabling the check engine."""
-    format: FormatOptions = Field(default_factory=FormatOptions)
-    """Options for the output format."""
-    model: FactoryOptions = Field(default_factory=FactoryOptions)
-    """Options for the ready-to-go model."""
-    solve: ParallelSolveOptions = Field(default_factory=ParallelSolveOptions)
-    """Options for the parallel solver."""
 
     def to_args(self) -> List[str]:
         """
@@ -80,20 +192,18 @@ class Options(BaseModel):
         """
 
         opt_dict = self.to_dict()
-        flattened = _flatten(opt_dict)
 
         default_options = Options()
         default_options_dict = default_options.to_dict()
-        default_flattened = _flatten(default_options_dict)
 
         args = []
-        for key, value in flattened.items():
+        for key, value in opt_dict.items():
             # We only care about custom options, so we skip the default ones.
-            default_value = default_flattened.get(key)
+            default_value = default_options_dict.get(key)
             if value == default_value:
                 continue
 
-            key = key.replace("_", "")
+            key = f"-{key.replace('_', '.').lower()}"
 
             str_value = json.dumps(value)
             if key in _DURATIONS_ARGS:
@@ -118,34 +228,33 @@ class Options(BaseModel):
 
         return args
 
+    @classmethod
+    def extract_from_dict(cls, data: Dict[str, Any]) -> "Options":
+        """
+        Extracts options from a dictionary. This dictionary may contain more
+        keys that are not part of the Nextroute options.
 
-def _flatten(nested: Dict[str, Any]) -> Dict[str, Any]:
-    """Flatten a nested dict."""
-
-    flattened = {}
-    for child_key, child_value in nested.items():
-        root_key = f"-{child_key}"
-        __set_children(flattened, root_key, child_value)
-
-    return flattened
-
+        Parameters
+        ----------
+        data : Dict[str, Any]
+            The dictionary to extract options from.
 
-def __set_children(flattened: Dict[str, Any], parent_key: str, parent_value: Any):
-    """Helper function for `__flatten`. it is invoked recursively on a child
-    value. If the child is not a dict, then the value is simply set on the
-    flattened dict. If the child is a dict, then the function is invoked
-    recursively on the child’s values, unitl a non-dict values is hit."""
+        Returns
+        ----------
+        Options
+            The Nextroute options.
+        """
 
-    new_key = parent_key
+        options = cls()
+        for key, value in data.items():
+            key = key.upper()
+            if not hasattr(options, key):
+                continue
 
-    if parent_value is None:
-        flattened[new_key] = parent_value
-        return
+            # Enums need to be handled manually.
+            if key == "CHECK_VERBOSITY":
+                value = Verbosity(value)
 
-    if isinstance(parent_value, dict):
-        for child_key, child_value in parent_value.items():
-            new_key = f"{parent_key}.{child_key}"
-            __set_children(flattened, new_key, child_value)
-        return
+            setattr(options, key, value)
 
-    flattened[new_key] = parent_value
+        return options

nextroute/schema/input.py

@@ -4,7 +4,8 @@
 Defines the input class.
 """
 
-from typing import Any, List, Optional
+from datetime import datetime
+from typing import Any, List, Optional, Union
 
 from nextroute.base_model import BaseModel
 from nextroute.schema.stop import AlternateStop, Stop, StopDefaults
@@ -30,6 +31,30 @@ class DurationGroup(BaseModel):
     """Stop IDs contained in the group."""
 
 
+class MatrixTimeFrame(BaseModel):
+    """Represents a time-dependent duration matrix or scaling factor."""
+
+    start_time: datetime
+    """Start time of the time frame."""
+    end_time: datetime
+    """End time of the time frame."""
+    matrix: Optional[List[List[float]]] = None
+    """Duration matrix for the time frame."""
+    scaling_factor: Optional[float] = None
+    """Scaling factor for the time frame."""
+
+
+class TimeDependentMatrix(BaseModel):
+    """Represents time-dependent duration matrices."""
+
+    vehicle_ids: Optional[List[str]] = None
+    """Vehicle IDs for which the duration matrix is defined."""
+    default_matrix: List[List[float]]
+    """Default duration matrix."""
+    matrix_time_frames: Optional[List[MatrixTimeFrame]] = None
+    """Time-dependent duration matrices."""
+
+
 class Input(BaseModel):
     """Input schema for Nextroute."""
 
@@ -46,10 +71,16 @@ class Input(BaseModel):
     """Default values for vehicles and stops."""
     distance_matrix: Optional[List[List[float]]] = None
     """Matrix of travel distances in meters between stops."""
-    duratrion_groups: Optional[List[DurationGroup]] = None
+    duration_groups: Optional[List[DurationGroup]] = None
     """Duration in seconds added when approaching the group."""
-    duration_matrix: Optional[List[List[float]]] = None
-    """Matrix of travel durations in seconds between stops."""
+    duration_matrix: Optional[
+        Union[
+            List[List[float]],
+            TimeDependentMatrix,
+            List[TimeDependentMatrix],
+        ]
+    ] = None
+    """Matrix of travel durations in seconds between stops as a single matrix or duration matrices."""
     options: Optional[Any] = None
     """Arbitrary options."""
     stop_groups: Optional[List[List[str]]] = None

nextroute/solve.py

@@ -6,6 +6,7 @@ Methods for solving a Vehicle Routing Problem with Nextroute.
 
 import json
 import os
+import platform
 import subprocess
 from typing import Any, Dict, Union
 
@@ -15,15 +16,9 @@ from nextroute.schema.output import Output
 
 SUPPORTED_OS = ["linux", "windows", "darwin"]
 """The operating systems supported by the Nextroute engine."""
-SUPPORTED_ARCHITECTURES = ["x86_64", "arm64", "aarch64"]
+SUPPORTED_ARCHITECTURES = ["amd64", "x86_64", "arm64", "aarch64"]
 """The architectures supported by the Nextroute engine."""
 
-_ARCHITECTURE_TRANSLATION = {
-    "x86_64": "amd64",
-    "arm64": "arm64",
-    "aarch64": "arm64",
-}
-
 
 def solve(
     input: Union[Input, Dict[str, Any]],
@@ -114,21 +109,17 @@ def solve(
     if isinstance(options, dict):
         options = Options.from_dict(options)
 
-    os_name = os.uname().sysname.lower()
+    os_name = platform.system().lower()
     if os_name not in SUPPORTED_OS:
         raise Exception(f'unsupported operating system: "{os_name}", supported os are: {", ".join(SUPPORTED_OS)}')
 
-    architecture = os.uname().machine.lower()
+    architecture = platform.machine().lower()
     if architecture not in SUPPORTED_ARCHITECTURES:
         raise Exception(
             f'unsupported architecture: "{architecture}", supported arch are: {", ".join(SUPPORTED_ARCHITECTURES)}'
         )
 
-    binary_name = f"nextroute-{os_name}-{_ARCHITECTURE_TRANSLATION[architecture]}"
-    if os_name == "windows":
-        binary_name += ".exe"
-
-    executable = os.path.join(os.path.dirname(__file__), "bin", binary_name)
+    executable = os.path.join(os.path.dirname(__file__), "bin", "nextroute.exe")
     if not os.path.exists(executable):
         raise Exception(f"missing Nextroute binary: {executable}")
 

nextroute/version.py

@@ -1,3 +1,5 @@
+# © 2019-present nextmv.io inc
+
 import os
 import subprocess
 

{nextroute-1.8.0.dev24.dist-info → nextroute-1.12.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: nextroute
-Version: 1.8.0.dev24
+Version: 1.12.3
 Summary: Nextroute is an engine for solving Vehicle Routing Problems (VRPs).
 Author-email: Nextmv <tech@nextmv.io>
 Maintainer-email: Nextmv <tech@nextmv.io>
@@ -104,10 +104,12 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: pydantic>=2.5.2
+Dynamic: license-file
 
 # Nextroute
 
@@ -197,7 +199,7 @@ file.
 
 For further information on how to get started, features, deployment, etc.,
 please refer to the [official
-documentation](https://www.nextmv.io/docs/vehicle-routing).
+documentation](https://www.nextmv.io/docs/vehicle-routing/get-started).
 
 ### Go
 
@@ -233,12 +235,7 @@ with open("cmd/input.json") as f:
     data = json.load(f)
 
 input = nextroute.schema.Input.from_dict(data)
-options = nextroute.Options(
-    solve=nextroute.ParallelSolveOptions(
-        duration=5,
-    ),
-)
-
+options = nextroute.Options(SOLVE_DURATION=5)
 output = nextroute.solve(input, options)
 print(json.dumps(output.to_dict(), indent=2))
 ```

nextroute-1.12.3.dist-info/RECORD

@@ -0,0 +1,26 @@
+nextroute-1.12.3.dist-info/RECORD,,
+nextroute-1.12.3.dist-info/WHEEL,sha256=entZNN85s-JxqcmXHTt39Ax198pJrOYoKFOQaLspAVk,110
+nextroute-1.12.3.dist-info/top_level.txt,sha256=KNsuo1j7tr-QvBFS_ELmo68OmJ-orEZiOXqstGLJDXA,16
+nextroute-1.12.3.dist-info/METADATA,sha256=IWx8wIDz9Eq2z-3bNW431o7hYu2q3HX0iJLH6A1MOn4,15612
+nextroute-1.12.3.dist-info/licenses/LICENSE,sha256=ElKAl6B15yj4LTFL_Dh1hje431kMHut2urxo5nheRWs,4107
+tests/solve_golden/__init__.py,sha256=MRZbyX5fYnxsXV0YP6lf32c5YYMo3NsEFqPwdwf5W18,32
+tests/solve_golden/main.py,sha256=VScx0kPD8ihGR5bSIpLrPTIxRh7mkk9YQ9g0eg8XZMc,1738
+tests/schema/test_input.py,sha256=kNIlUFqCkvvQieuJIo7-6C_NB9PZqZ72NpGwUWtDZcA,1851
+tests/schema/__init__.py,sha256=MRZbyX5fYnxsXV0YP6lf32c5YYMo3NsEFqPwdwf5W18,32
+tests/schema/test_output.py,sha256=i0VreVBXamC-Pk-z7X3W9APjmjfG8iOPAt2jxP4hDQA,11579
+nextroute/options.py,sha256=tZcTLIjsx-6fq9Q9Y-Z8syKbPqGyR3GV6vfpWvVmzLQ,10280
+nextroute/version.py,sha256=aA_wmIifNRCzxBigX4cSz1Y2CdXvuBNIiY7Nem5UqRA,325
+nextroute/__init__.py,sha256=wBHS73T_Mm2MfcEx4chZCI1QMbV-a1D7bw7megFLgb4,529
+nextroute/base_model.py,sha256=Jl205oJZvndkY8rIomZD2k5YhlGgRBn_2I1BKwQ8Vkk,541
+nextroute/__about__.py,sha256=H71OIfyHAXJOiG4wuGcoP506V3in6aScHaOMWCJknuM,57
+nextroute/solve.py,sha256=It1kDEdFk_AXX-gEUjvQbc7C-0ma9bEPRbnC_bHMsUU,4192
+nextroute/bin/nextroute.exe,sha256=uqL63K4vXMiKLTpZqa8APeh7kmutF7frc4EGSCMm4Eo,14990208
+nextroute/schema/stop.py,sha256=leKhNC0rcEo64NMNofDuVYnfDNLaqfLZ-mSxUEAwoZk,2199
+nextroute/schema/vehicle.py,sha256=0W3q-upCn5yEUDX2BBeq5TkOCsrlLsk3Wao-T74nDmU,2535
+nextroute/schema/__init__.py,sha256=KSlnpJQMnCDq5IXyiltt9CiafcxUH40B3FdE1fc5wdI,1167
+nextroute/schema/location.py,sha256=hihllMU3IXxQHugGC4Wn_TzDPr5zm4xqVqRsKanwrmA,301
+nextroute/schema/input.py,sha256=uidXX_hpv1KpiIUCc_XhiiQf69vxiav9DsXfiLtpD2s,2856
+nextroute/schema/statistics.py,sha256=lNlb1mcpR6xWQclG-fkDMnFoy-sEKpXKk80zU1TKrpQ,3600
+nextroute/schema/output.py,sha256=rJv_PpP0X0MdLTRa2tbDsLLbGhTRi43hGmMNmzvNZEw,4810
+nextroute/check/__init__.py,sha256=Hrw5LUqdMeaBEsoIrJmWDhmAKAzGuzDnoBExwNWJvlU,1303
+nextroute/check/schema.py,sha256=hBC0Usw4_rEJHsWDxDtIi0-d6byXt8f9eYqBE9hqiCc,5853

{nextroute-1.8.0.dev24.dist-info → nextroute-1.12.3.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.44.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: false
 Tag: cp312-cp312-macosx_13_0_x86_64
 

tests/solve_golden/main.py

@@ -0,0 +1,50 @@
+# This script is copied to the `src` root so that the `nextroute` import is
+# resolved. It is fed an input via stdin and is meant to write the output to
+# stdout.
+import nextmv
+
+import nextroute
+
+
+def main() -> None:
+    """Entry point for the program."""
+
+    parameters = [
+        nextmv.Parameter("input", str, "", "Path to input file. Default is stdin.", False),
+        nextmv.Parameter("output", str, "", "Path to output file. Default is stdout.", False),
+    ]
+
+    default_options = nextroute.Options()
+    for name, default_value in default_options.to_dict().items():
+        parameters.append(nextmv.Parameter(name.lower(), type(default_value), default_value, name, False))
+
+    options = nextmv.Options(*parameters)
+
+    input = nextmv.load_local(options=options, path=options.input)
+
+    nextmv.log("Solving vehicle routing problem:")
+    nextmv.log(f"  - stops: {len(input.data.get('stops', []))}")
+    nextmv.log(f"  - vehicles: {len(input.data.get('vehicles', []))}")
+
+    model = DecisionModel()
+    output = model.solve(input)
+    nextmv.write_local(output, path=options.output)
+
+
+class DecisionModel(nextmv.Model):
+    def solve(self, input: nextmv.Input) -> nextmv.Output:
+        """Solves the given problem and returns the solution."""
+
+        nextroute_input = nextroute.schema.Input.from_dict(input.data)
+        nextroute_options = nextroute.Options.extract_from_dict(input.options.to_dict())
+        nextroute_output = nextroute.solve(nextroute_input, nextroute_options)
+
+        return nextmv.Output(
+            options=input.options,
+            solution=nextroute_output.solutions[0].to_dict(),
+            statistics=nextroute_output.statistics.to_dict(),
+        )
+
+
+if __name__ == "__main__":
+    main()

nextroute/check/options.py

@@ -1,31 +0,0 @@
-# © 2019-present nextmv.io inc
-
-"""
-Options for the Nextroute check engine.
-"""
-
-from enum import Enum
-
-from nextroute.base_model import BaseModel
-
-
-class Verbosity(str, Enum):
-    """Format of an `Input`."""
-
-    OFF = "off"
-    """The check engine is not run."""
-    LOW = "low"
-    """Low verbosity for the check engine."""
-    MEDIUM = "medium"
-    """Medium verbosity for the check engine."""
-    HIGH = "high"
-    """High verbosity for the check engine."""
-
-
-class Options(BaseModel):
-    """Options for the Nextroute check engine."""
-
-    duration: float = 30
-    """Maximum duration of the check, in seconds."""
-    verbosity: Verbosity = Verbosity.OFF
-    """Verbosity of the check engine."""

nextroute/factory/__init__.py

@@ -1,16 +0,0 @@
-# © 2019-present nextmv.io inc
-
-"""
-Functionality for creating a ready-to-go Nextroute model.
-"""
-
-from .options import Constraints as Constraints
-from .options import DisableConstraints as DisableConstraints
-from .options import DisableProperties as DisableProperties
-from .options import DisableValidate as DisableValidate
-from .options import EnableConstraints as EnableConstraints
-from .options import EnableValidate as EnableValidate
-from .options import Objectives as Objectives
-from .options import Options as Options
-from .options import Properties as Properties
-from .options import Validate as Validate

nextroute/factory/options.py

@@ -1,146 +0,0 @@
-# © 2019-present nextmv.io inc
-
-"""
-Options for the Nextroute factory.
-"""
-
-from typing import List
-
-from pydantic import Field
-
-from nextroute.base_model import BaseModel
-
-
-class DisableConstraints(BaseModel):
-    """Options for disabling specific constraints."""
-
-    attributes: bool = False
-    """Ignore the compatibility attributes constraint."""
-    capacity: bool = False
-    """Ignore the capacity constraint for all resources."""
-    capacities: List[str] = Field(default_factory=list)
-    """Ignore the capacity constraint for the given resource names."""
-    distance_limit: bool = False
-    """Ignore the distance limit constraint."""
-    groups: bool = False
-    """Ignore the groups constraint."""
-    maximum_duration: bool = False
-    """Ignore the maximum duration constraint."""
-    maximum_stops: bool = False
-    """Ignore the maximum stops constraint."""
-    maximum_wait_stop: bool = False
-    """Ignore the maximum stop wait constraint."""
-    maximum_wait_vehicle: bool = False
-    """Ignore the maximum vehicle wait constraint."""
-    mixing_items: bool = False
-    """Ignore the do not mix items constraint."""
-    precedence: bool = False
-    """Ignore the precedence (pickups & deliveries) constraint."""
-    vehicle_start_time: bool = False
-    """Ignore the vehicle start time constraint."""
-    vehicle_end_time: bool = False
-    """Ignore the vehicle end time constraint."""
-    start_time_windows: bool = False
-    """Ignore the start time windows constraint."""
-
-
-class EnableConstraints(BaseModel):
-    """Options for enabling specific constraints."""
-
-    cluster: bool = False
-    """Enable the cluster constraint."""
-
-
-class Constraints(BaseModel):
-    """Options for configuring constraints."""
-
-    disable: DisableConstraints = Field(default_factory=DisableConstraints)
-    """Options for disabling specific constraints."""
-    enable: EnableConstraints = Field(default_factory=EnableConstraints)
-    """Options for enabling specific constraints."""
-
-
-class Objectives(BaseModel):
-    """Options for configuring objectives."""
-
-    capacities: str = ""
-    """
-    Capacity objective, provide triple for each resource
-    `name:default;factor:1.0;offset;0.0`.
-    """
-    min_stops: float = 1.0
-    """Factor to weigh the min stops objective."""
-    early_arrival_penalty: float = 1.0
-    """Factor to weigh the early arrival objective."""
-    late_arrival_penalty: float = 1.0
-    """Factor to weigh the late arrival objective."""
-    vehicle_activation_penalty: float = 1.0
-    """Factor to weigh the vehicle activation objective."""
-    travel_duration: float = 0.0
-    """Factor to weigh the travel duration objective."""
-    vehicles_duration: float = 1.0
-    """Factor to weigh the vehicles duration objective."""
-    unplanned_penalty: float = 1.0
-    """Factor to weigh the unplanned objective."""
-    cluster: float = 0.0
-    """Factor to weigh the cluster objective."""
-
-
-class DisableProperties(BaseModel):
-    """Options for disabling specific properties."""
-
-    durations: bool = False
-    """Ignore the durations of stops."""
-    stop_duration_multipliers: bool = False
-    """Ignore the stop duration multipliers defined on vehicles."""
-    duration_groups: bool = False
-    """Ignore the durations groups of stops."""
-    initial_solution: bool = False
-    """Ignore the initial solution."""
-
-
-class Properties(BaseModel):
-    """Options for configuring properties."""
-
-    disable: DisableProperties = Field(default_factory=DisableProperties)
-    """Options for disabling specific properties."""
-
-
-class DisableValidate(BaseModel):
-    """Options for disabling specific validations."""
-
-    start_time: bool = False
-    """Disable the start time validation."""
-    resources: bool = False
-    """Disable the resources validation."""
-
-
-class EnableValidate(BaseModel):
-    """Options for enabling specific validations."""
-
-    matrix: bool = False
-    """Enable matrix validation."""
-    matrix_asymmetry_tolerance: int = 20
-    """Percentage of acceptable matrix asymmetry, requires matrix validation enabled."""
-
-
-class Validate(BaseModel):
-    """Options for configuring validations."""
-
-    disable: DisableValidate = Field(default_factory=DisableValidate)
-    """Options for disabling specific validations"""
-    enable: EnableValidate = Field(default_factory=EnableValidate)
-    """Options for enabling specific validations"""
-
-
-class Options(BaseModel):
-    """Options that configure how a Nextroute model is built."""
-
-    constraints: Constraints = Field(default_factory=Constraints)
-    """Options for configuring constraints."""
-    objectives: Objectives = Field(default_factory=Objectives)
-    """Options for configuring objectives."""
-    properties: Properties = Field(default_factory=Properties)
-    """Options for configuring properties."""
-    validate_options: Validate = Field(default_factory=Validate, alias="validate")
-    """Options for configuring validations."""

nextroute-1.8.0.dev24.dist-info/RECORD

@@ -1,29 +0,0 @@
-tests/nextroute_python/test_options.py,sha256=8MJM05tF12M2kUjasA0kStrMFoIC1m9jDlydybpSUmI,4960
-tests/nextroute_python/__init__.py,sha256=MRZbyX5fYnxsXV0YP6lf32c5YYMo3NsEFqPwdwf5W18,32
-tests/nextroute_python/schema/test_input.py,sha256=kNIlUFqCkvvQieuJIo7-6C_NB9PZqZ72NpGwUWtDZcA,1851
-tests/nextroute_python/schema/__init__.py,sha256=MRZbyX5fYnxsXV0YP6lf32c5YYMo3NsEFqPwdwf5W18,32
-tests/nextroute_python/schema/test_output.py,sha256=i0VreVBXamC-Pk-z7X3W9APjmjfG8iOPAt2jxP4hDQA,11579
-nextroute/options.py,sha256=swxZjQxkZ1-YbZ4RodaVsxZLc-6Ii5N6dp6veCPPl28,4647
-nextroute/version.py,sha256=LIMuiAulNxiYKzNKUC6Qc6R67OgxI-54dtlvVHBFto8,292
-nextroute/__init__.py,sha256=1NRMAxEvJKZ6JRwPGRK2C7LbfDH7SFqjSCGGLeqdFlM,669
-nextroute/base_model.py,sha256=Jl205oJZvndkY8rIomZD2k5YhlGgRBn_2I1BKwQ8Vkk,541
-nextroute/__about__.py,sha256=OdrvvA4KQR6CdtHBxVgVsNdTuVWgCqdn-eK4jSa7GJk,62
-nextroute/solve.py,sha256=Fdo35yPnz_54CyqVUy46uGQ6WjTBZy3alJKz8yI6Iok,4409
-nextroute/bin/nextroute.exe,sha256=U5ohy1yYxPwUmct_Pd6SuO78Tg_7kybZDsbxfgsySDk,13296048
-nextroute/schema/stop.py,sha256=leKhNC0rcEo64NMNofDuVYnfDNLaqfLZ-mSxUEAwoZk,2199
-nextroute/schema/vehicle.py,sha256=0W3q-upCn5yEUDX2BBeq5TkOCsrlLsk3Wao-T74nDmU,2535
-nextroute/schema/__init__.py,sha256=KSlnpJQMnCDq5IXyiltt9CiafcxUH40B3FdE1fc5wdI,1167
-nextroute/schema/location.py,sha256=hihllMU3IXxQHugGC4Wn_TzDPr5zm4xqVqRsKanwrmA,301
-nextroute/schema/input.py,sha256=8_-xi-P2t-A6mObLscKavT-Ro0td9VECp2pZOQ1dWmo,1863
-nextroute/schema/statistics.py,sha256=lNlb1mcpR6xWQclG-fkDMnFoy-sEKpXKk80zU1TKrpQ,3600
-nextroute/schema/output.py,sha256=rJv_PpP0X0MdLTRa2tbDsLLbGhTRi43hGmMNmzvNZEw,4810
-nextroute/check/options.py,sha256=6fMFJvnd84OPmpGiFtSZmtVJmn0FdmX0PH71dZeQdt4,703
-nextroute/check/__init__.py,sha256=cYCx73rR1gOysg1XHvothsdsN6sP-1jAiVIjxtNzaVg,1387
-nextroute/check/schema.py,sha256=hBC0Usw4_rEJHsWDxDtIi0-d6byXt8f9eYqBE9hqiCc,5853
-nextroute/factory/options.py,sha256=XMvfev4K5RGclMxkX5tCu5JhV5GchBWeOpptn3cdL9I,4948
-nextroute/factory/__init__.py,sha256=kqi5fdunYqwBP3uOsBu-m0vHQANjOiyJpnKZ1xluER4,614
-nextroute-1.8.0.dev24.dist-info/RECORD,,
-nextroute-1.8.0.dev24.dist-info/LICENSE,sha256=ElKAl6B15yj4LTFL_Dh1hje431kMHut2urxo5nheRWs,4107
-nextroute-1.8.0.dev24.dist-info/WHEEL,sha256=kEDwEAybh1yMTwMF4usCWe2WGZj5bJzouP4ddPUefKc,111
-nextroute-1.8.0.dev24.dist-info/top_level.txt,sha256=KNsuo1j7tr-QvBFS_ELmo68OmJ-orEZiOXqstGLJDXA,16
-nextroute-1.8.0.dev24.dist-info/METADATA,sha256=5wRe6kY7cqQuvwgGortFEhJ0Uj_VRe0uy7D5EnKj2hY,15587

tests/nextroute_python/test_options.py

@@ -1,141 +0,0 @@
-import unittest
-
-import nextroute
-import nextroute.check
-import nextroute.factory
-from nextroute import options
-
-
-class TestOptions(unittest.TestCase):
-    def test_options_default_values(self):
-        opt = nextroute.Options()
-        options_dict = opt.to_dict()
-        self.assertDictEqual(
-            options_dict,
-            {
-                "check": {"duration": 30.0, "verbosity": "off"},
-                "format": {"disable": {"progression": False}},
-                "model": {
-                    "constraints": {
-                        "disable": {
-                            "attributes": False,
-                            "capacity": False,
-                            "capacities": [],
-                            "distance_limit": False,
-                            "groups": False,
-                            "maximum_duration": False,
-                            "maximum_stops": False,
-                            "maximum_wait_stop": False,
-                            "maximum_wait_vehicle": False,
-                            "mixing_items": False,
-                            "precedence": False,
-                            "vehicle_start_time": False,
-                            "vehicle_end_time": False,
-                            "start_time_windows": False,
-                        },
-                        "enable": {"cluster": False},
-                    },
-                    "objectives": {
-                        "capacities": "",
-                        "min_stops": 1.0,
-                        "early_arrival_penalty": 1.0,
-                        "late_arrival_penalty": 1.0,
-                        "vehicle_activation_penalty": 1.0,
-                        "travel_duration": 0.0,
-                        "vehicles_duration": 1.0,
-                        "unplanned_penalty": 1.0,
-                        "cluster": 0.0,
-                    },
-                    "properties": {
-                        "disable": {
-                            "durations": False,
-                            "stop_duration_multipliers": False,
-                            "duration_groups": False,
-                            "initial_solution": False,
-                        }
-                    },
-                    "validate": {
-                        "disable": {"start_time": False, "resources": False},
-                        "enable": {"matrix": False, "matrix_asymmetry_tolerance": 20},
-                    },
-                },
-                "solve": {
-                    "iterations": -1,
-                    "duration": 5.0,
-                    "parallel_runs": -1,
-                    "start_solutions": -1,
-                    "run_deterministically": False,
-                },
-            },
-        )
-
-    def test_flatten(self):
-        nested = {
-            "foo": {
-                "bar": False,
-                "baz": 1,
-                "roh": "doh",
-            },
-            "bar": {
-                "baz": {
-                    "bah": "roh",
-                }
-            },
-            "baz": False,
-            "bah": 1,
-        }
-        flat = options._flatten(nested)
-        self.assertDictEqual(
-            flat,
-            {
-                "-foo.bar": False,
-                "-foo.baz": 1,
-                "-foo.roh": "doh",
-                "-bar.baz.bah": "roh",
-                "-baz": False,
-                "-bah": 1,
-            },
-        )
-
-    def test_options_to_args(self):
-        # Default options should not produce any arguments.
-        opt = nextroute.Options()
-        args = opt.to_args()
-        self.assertListEqual(args, [])
-
-        # Only options that are not default should produce arguments.
-        opt2 = nextroute.Options(
-            check=nextroute.check.Options(
-                duration=4,
-                verbosity=nextroute.check.Verbosity.MEDIUM,
-            ),
-            solve=nextroute.ParallelSolveOptions(
-                duration=4,
-                iterations=-1,  # Default value should be skipped.
-            ),
-            model=nextroute.factory.Options(
-                constraints=nextroute.factory.Constraints(
-                    disable=nextroute.factory.DisableConstraints(
-                        attributes=True,
-                    ),
-                ),
-                validate=nextroute.factory.Validate(
-                    enable=nextroute.factory.EnableValidate(
-                        matrix=False,  # This option should be skipped because it is bool False.
-                    ),
-                ),
-            ),
-        )
-        args2 = opt2.to_args()
-        self.assertListEqual(
-            args2,
-            [
-                "-check.duration",
-                "4.0s",
-                "-check.verbosity",
-                "medium",
-                "-model.constraints.disable.attributes",  # Bool flags do not have values.
-                "-solve.duration",
-                "4.0s",
-            ],
-        )