Change signature of solve in nextmv.Model

Author: sebastian-quintero

README.md

@@ -238,10 +238,10 @@ Write the output data after a run is completed.
 #### Model
 
 A decision model is a program that makes decisions, i.e.: solves decision
-problems. The model takes in an input (representing the problem data), options
-to configure the program, and returns an output, which is the solution to the
-decision problem. The `nextmv.Model` class is the base class for all models. It
-holds the necessary logic to handle all decisions.
+problems. The model takes in an input (representing the problem data and
+options) and returns an output, which is the solution to the decision problem.
+The `nextmv.Model` class is the base class for all models. It holds the
+necessary logic to handle all decisions.
 
 When creating your own decision model, you must create a class that inherits
 from `nextmv.Model` and implement the `solve` method.
@@ -250,7 +250,7 @@ from `nextmv.Model` and implement the `solve` method.
 import nextmv
 
 class YourCustomModel(nextmv.Model):
-    def solve(self, input: nextmv.Input, options: nextmv.Options) -> nextmv.Output:
+    def solve(self, input: nextmv.Input) -> nextmv.Output:
         """Implement the logic to solve the decision problem here."""
         pass
 ```
@@ -296,15 +296,15 @@ import highspy
 import nextmv
 
 class DecisionModel(nextmv.Model):
-    def solve(self, input: nextmv.Input, options: nextmv.Options) -> nextmv.Output:
+    def solve(self, input: nextmv.Input) -> nextmv.Output:
         """Solves the given problem and returns the solution."""
 
         start_time = time.time()
 
         # Creates the solver.
         solver = highspy.Highs()
         solver.silent()  # Solver output ignores stdout redirect, silence it.
-        solver.setOptionValue("time_limit", options.duration)
+        solver.setOptionValue("time_limit", input.options.duration)
 
         # Initializes the linear sums.
         weights = 0.0
@@ -330,7 +330,7 @@ class DecisionModel(nextmv.Model):
             item["item"] for item in items if solver.val(item["variable"]) > 0.9
         ]
 
-        options.version = version("highspy")
+        input.options.version = version("highspy")
 
         statistics = nextmv.Statistics(
             run=nextmv.RunStatistics(duration=time.time() - start_time),
@@ -345,7 +345,7 @@ class DecisionModel(nextmv.Model):
         )
 
         return nextmv.Output(
-            options=options,
+            options=input.options,
             solution={"items": chosen_items},
             statistics=statistics,
         )
@@ -361,7 +361,7 @@ import nextmv
 
 model = DecisionModel()
 input = nextmv.Input(data=sample_input, options=options)
-output = model.solve(input, options)
+output = model.solve(input)
 print(json.dumps(output.solution, indent=2))
 ```
 
@@ -446,7 +446,7 @@ There are two strategies to push an application to the Nextmv Cloud:
     from nextmv import cloud
 
     class CustomDecisionModel(nextmv.Model):
-        def solve(self, input: nextmv.Input, options: nextmv.Options) -> nextmv.Output:
+        def solve(self, input: nextmv.Input) -> nextmv.Output:
             """Implement the logic to solve the decision problem here."""
             pass
 

nextmv/__entrypoint__.py

@@ -11,7 +11,6 @@
 
 from nextmv.cloud.manifest import Manifest
 from nextmv.input import load_local
-from nextmv.model import ModelConfiguration
 from nextmv.options import Options
 from nextmv.output import write_local
 
@@ -28,18 +27,14 @@ def main() -> None:
         options = Options.from_parameters_dict(parameters_dict)
 
     # Load the model.
-    model_configuration = ModelConfiguration(
-        name=manifest.python.model.name,
-        options=options,
-    )
     loaded_model = load_model(
-        model_uri=model_configuration.name,
+        model_uri=manifest.python.model.name,
         suppress_warnings=True,
     )
 
     # Load the input and solve the model by using mlflow’s inference API.
     input = load_local(options=options)
-    output = loaded_model.predict(input, params=options.to_dict())
+    output = loaded_model.predict(input)
 
     # Write the output.
     write_local(output)

nextmv/cloud/application.py

@@ -712,13 +712,13 @@ def push(
         # Define the model that makes decisions. This model uses the Nextroute
         # library to solve a vehicle routing problem.
         class DecisionModel(nextmv.Model):
-            def solve(self, input: nextmv.Input, options: nextmv.Options) -> nextmv.Output:
+            def solve(self, input: nextmv.Input) -> nextmv.Output:
                 nextroute_input = nextroute.schema.Input.from_dict(input.data)
-                nextroute_options = nextroute.Options.extract_from_dict(options.to_dict())
+                nextroute_options = nextroute.Options.extract_from_dict(input.options.to_dict())
                 nextroute_output = nextroute.solve(nextroute_input, nextroute_options)
 
                 return nextmv.Output(
-                    options=options,
+                    options=input.options,
                     solution=nextroute_output.solutions[0].to_dict(),
                     statistics=nextroute_output.statistics.to_dict(),
                 )

nextmv/model.py

@@ -70,32 +70,30 @@ class Model:
     # Define the model that makes decisions. This model uses the Nextroute library
     # to solve a routing problem.
     class DecisionModel(nextmv.Model):
-        def solve(self, input: nextmv.Input, options: nextmv.Options) -> nextmv.Output:
+        def solve(self, input: nextmv.Input) -> nextmv.Output:
             nextroute_input = nextroute.schema.Input.from_dict(input.data)
-            nextroute_options = nextroute.Options.extract_from_dict(options.to_dict())
+            nextroute_options = nextroute.Options.extract_from_dict(input.options.to_dict())
             nextroute_output = nextroute.solve(nextroute_input, nextroute_options)
 
             return nextmv.Output(
-                options=options,
+                options=input.options,
                 solution=nextroute_output.solutions[0].to_dict(),
                 statistics=nextroute_output.statistics.to_dict(),
             )
         ```
     """
 
-    def solve(self, input: Input, options: Options) -> Output:
+    def solve(self, input: Input) -> Output:
         """
         The `solve` method is the main entry point of your model. You must
-        implement this method yourself. It receives a `nextmv.Input` and
-        `nextmv.Options` and should process them to produce a `nextmv.Output`,
-        which is the solution to the decision model/problem.
+        implement this method yourself. It receives a `nextmv.Input` and should
+        process it to produce a `nextmv.Output`, which is the solution to the
+        decision model/problem.
 
         Parameters
         ----------
         input : Input
             The input data that the model will use to make a decision.
-        options : Options
-            The options that the model will use to make a decision.
 
         Returns
         -------
@@ -142,7 +140,7 @@ class MLFlowModel(PythonModel):
             Nextmv `DecisionModel` into an `mlflow.pyfunc.PythonModel`. This
             class must comply with the inference API of mlflow, which is why it
             has a `predict` method. The translation happens by having this
-            `predict` methos call the user-defined `solve` method of the
+            `predict` method call the user-defined `solve` method of the
             `DecisionModel`.
             """
 
@@ -155,8 +153,7 @@ def predict(mlflow_self, context, model_input, params=None) -> Any:
                 [python_function]: https://mlflow.org/docs/latest/python_api/mlflow.pyfunc.html
                 """
 
-                options = Options.from_dict(params)
-                return self.solve(model_input, options)
+                return self.solve(model_input)
 
         # Some annoying logging from mlflow must be disabled.
         logging.disable(logging.CRITICAL)

tests/test_entrypoint/test_entrypoint.py

@@ -10,7 +10,7 @@
 
 
 class SimpleDecisionModel(nextmv.Model):
-    def solve(self, input: nextmv.Input, options: nextmv.Options) -> nextmv.Output:
+    def solve(self, input: nextmv.Input) -> nextmv.Output:
         return nextmv.Output(
             solution={"foo": "bar"},
             statistics={"baz": "qux"},

tests/test_model.py

@@ -8,7 +8,7 @@
 class ModelForTesting(nextmv.Model):
     """Dummy decision model for testing purposes."""
 
-    def solve(self, input: nextmv.Input, options: nextmv.Options) -> nextmv.Output:
+    def solve(self, input: nextmv.Input) -> nextmv.Output:
         return nextmv.Output()