desdeo 2.0.0__py3-none-any.whl → 2.1.0__py3-none-any.whl

desdeo/problem/pyomo_evaluator.py

@@ -3,7 +3,7 @@
 import itertools
 from collections.abc import Iterable
 from operator import eq as _eq
-from operator import le as _le
+from operator import le as _python_le
 
 import pyomo.environ as pyomo
 
@@ -19,6 +19,18 @@ from desdeo.problem.schema import (
 )
 
 
+def _le(expr, rhs, name):
+    # scalar → single constraint
+    if not expr.is_indexed():
+        tmp_expr = _python_le(expr, rhs)
+        return pyomo.Constraint(expr=tmp_expr, name=name)
+
+    # indexed → one row per index
+    tmp = pyomo.Constraint(expr.index_set(), rule=lambda m, *idx: expr[idx] <= rhs)
+    tmp.construct()
+    return tmp
+
+
 class PyomoEvaluatorError(Exception):
     """Raised when an error within the PyomoEvaluator class is encountered."""
 
@@ -159,7 +171,7 @@ class PyomoEvaluator:
                 else:
                     initial_value = (
                         var.initial_value
-                        if var.lowerbound is None and var.upperbound is None
+                        if var.lowerbound is None or var.upperbound is None
                         else (var.lowerbound + var.upperbound) / 2
                     )
 
@@ -321,16 +333,17 @@ class PyomoEvaluator:
             match con_type := cons.cons_type:
                 case ConstraintTypeEnum.LTE:
                     # constraints in DESDEO are defined such that they must be less than zero
-                    pyomo_expr = _le(pyomo_expr, 0)
+                    pyomo_expr = _le(pyomo_expr, 0, cons.name)
                 case ConstraintTypeEnum.EQ:
                     pyomo_expr = _eq(pyomo_expr, 0)
                 case _:
                     msg = f"Constraint type of {con_type} not supported. Must be one of {ConstraintTypeEnum}."
                     raise PyomoEvaluatorError(msg)
 
-            cons_expr = pyomo.Constraint(expr=pyomo_expr, name=cons.name)
+            # cons_expr = pyomo.Constraint(expr=pyomo_expr, name=cons.name)
 
-            setattr(model, cons.symbol, cons_expr)
+            setattr(model, cons.symbol, pyomo_expr)
+            # getattr(model, cons.symbol).construct()
 
         return model
 
@@ -429,9 +442,15 @@ class PyomoEvaluator:
             for extra in self.problem.extra_funcs:
                 result_dict[extra.symbol] = pyomo.value(getattr(self.model, extra.symbol))
 
+        # TODO: after implementing TensorConstraint, fix this
         if self.problem.constraints is not None:
             for const in self.problem.constraints:
-                result_dict[const.symbol] = pyomo.value(getattr(self.model, const.symbol))
+                obj = getattr(self.model, const.symbol)
+
+                if obj.is_indexed():
+                    result_dict[const.symbol] = {k: pyomo.value(obj[k]) for k in obj}
+                else:
+                    result_dict[const.symbol] = pyomo.value(obj)
 
         if self.problem.scalarization_funcs is not None:
             for scal in self.problem.scalarization_funcs:

desdeo/problem/schema.py

@@ -16,7 +16,7 @@ from collections.abc import Iterable
 from enum import Enum
 from itertools import product
 from pathlib import Path
-from typing import TYPE_CHECKING, Annotated, Any, Literal, TypeAliasType
+from typing import TYPE_CHECKING, Annotated, Any, Literal, Self, TypeAliasType
 
 import numpy as np
 from pydantic import (
@@ -260,7 +260,7 @@ class ObjectiveTypeEnum(str, Enum):
 class Constant(BaseModel):
     """Model for a constant."""
 
-    model_config = ConfigDict(frozen=True, from_attributes=True)
+    model_config = ConfigDict(frozen=True, from_attributes=True, extra="forbid")
 
     name: str = Field(
         description=(
@@ -284,7 +284,7 @@ class Constant(BaseModel):
 class TensorConstant(BaseModel):
     """Model for a tensor containing constant values."""
 
-    model_config = ConfigDict(frozen=True, arbitrary_types_allowed=True, from_attributes=True)
+    model_config = ConfigDict(frozen=True, arbitrary_types_allowed=True, from_attributes=True, extra="forbid")
 
     name: str = Field(description="Descriptive name of the tensor representing the values. E.g., 'distances'")
     """Descriptive name of the tensor representing the values. E.g., 'distances'"""
@@ -377,7 +377,7 @@ class TensorConstant(BaseModel):
 class Variable(BaseModel):
     """Model for a variable."""
 
-    model_config = ConfigDict(frozen=True, from_attributes=True)
+    model_config = ConfigDict(frozen=True, from_attributes=True, extra="forbid")
 
     name: str = Field(
         description="Descriptive name of the variable. This can be used in UI and visualizations. Example: 'velocity'."
@@ -407,7 +407,7 @@ class Variable(BaseModel):
 class TensorVariable(BaseModel):
     """Model for a tensor, e.g., vector variable."""
 
-    model_config = ConfigDict(frozen=True, arbitrary_types_allowed=True, from_attributes=True)
+    model_config = ConfigDict(frozen=True, arbitrary_types_allowed=True, from_attributes=True, extra="forbid")
 
     name: str = Field(
         description="Descriptive name of the variable. This can be used in UI and visualizations. Example: 'velocity'."
@@ -585,7 +585,7 @@ class ExtraFunction(BaseModel):
     they are needed for other computations related to the problem.
     """
 
-    model_config = ConfigDict(frozen=True, from_attributes=True)
+    model_config = ConfigDict(frozen=True, from_attributes=True, extra="forbid")
 
     name: str = Field(
         description=("Descriptive name of the function. Example: 'normalization'."),
@@ -663,7 +663,7 @@ class ExtraFunction(BaseModel):
 class ScalarizationFunction(BaseModel):
     """Model for scalarization of the problem."""
 
-    model_config = ConfigDict(from_attributes=True)
+    model_config = ConfigDict(from_attributes=True, extra="forbid")
 
     name: str = Field(description=("Name of the scalarization function."))
     """Name of the scalarization function."""
@@ -712,10 +712,35 @@ class ScalarizationFunction(BaseModel):
     )
 
 
+class Url(BaseModel):
+    """Model for a URL."""
+
+    model_config = ConfigDict(frozen=True, from_attributes=True, extra="forbid")
+
+    url: str = Field(
+        description=(
+            "A URL to the simulator. A GET request to this URL should be used to evaluate solutions in batches."
+        )
+    )
+    """A URL to the simulator. A GET request to this URL should be used to evaluate solutions in batches."""
+
+    auth: tuple[str, str] | None = Field(
+        description=(
+            "Optional. A tuple of username and password to be used for authentication when making requests to the URL."
+        ),
+        default=None,
+    )
+    """Optional. A tuple of username and password to be used for authentication when making requests to the URL."""
+    # Add headers and stuff for a proper HTTP request if needed in the future idk
+
+
 class Simulator(BaseModel):
-    """Model for simulator data."""
+    """Model for simulator data.
+
+    One of `file` or `url` must be provided, but not both.
+    """
 
-    model_config = ConfigDict(frozen=True, from_attributes=True)
+    model_config = ConfigDict(frozen=True, from_attributes=True, extra="forbid")
 
     name: str = Field(
         description=("Descriptive name of the simulator. This can be used in UI and visualizations."),
@@ -727,10 +752,15 @@ class Simulator(BaseModel):
             " It may also be used in UIs and visualizations."
         ),
     )
-    file: Path = Field(
-        description=("Path to a python file with the connection to simulators."),
-    )
+    file: Path | None = Field(description=("Path to a python file with the connection to simulators."), default=None)
     """Path to a python file with the connection to simulators."""
+    url: Url | None = Field(
+        description=(
+            "Optional. A URL to the simulator. A GET request to this URL should be used to evaluate solutions in batches."
+        ),
+        default=None,
+    )
+    """Optional. A URL to the simulator. A GET request to this URL should be used to evaluate solutions in batches."""
     parameter_options: dict | None = Field(
         description=(
             "Parameters to the simulator that are not decision variables, but affect the results."
@@ -741,12 +771,30 @@ class Simulator(BaseModel):
     """Parameters to the simulator that are not decision variables, but affect the results.
     Format is similar to decision variables. Can be 'None'."""
 
+    # Check that either file or url is provided, but not both
+    @model_validator(mode="after")
+    def check_file_or_url(self) -> Self:
+        """Ensure that either file or url is provided, but not both."""
+        if self.file is None and self.url is None:
+            raise ValueError("Either 'file' or 'url' must be provided.")
+        if self.file is not None and self.url is not None:
+            raise ValueError("Only one of 'file' or 'url' can be provided.")
+        return self
+
 
 class Objective(BaseModel):
     """Model for an objective function."""
 
-    model_config = ConfigDict(frozen=True, from_attributes=True)
+    model_config = ConfigDict(frozen=True, from_attributes=True, extra="forbid")
 
+    """A longer description for the objective."""
+    description: str | None = Field(
+        description=(
+            "A longer description of the objective function. This can be used in UI and visualizations. \
+            Meant to have longer text than what name should have."
+        ),
+        default=None,
+    )
     name: str = Field(
         description=(
             "Descriptive name of the objective function. This can be used in UI and visualizations. Example: 'time'."
@@ -786,9 +834,9 @@ class Objective(BaseModel):
     variable/constant/extra function. Can be 'None' for 'data_based', 'simulator' or
     'surrogate' objective functions. If 'None', either 'simulator_path' or 'surrogates' must
     not be 'None'."""
-    simulator_path: Path | None = Field(
+    simulator_path: Path | Url | None = Field(
         description=(
-            "Path to a python file with the connection to simulators. Must be a valid Path."
+            "Path to a python file or http server with the connection to simulators. Must be a valid Path or url."
             "Can be 'None' for 'analytical', 'data_based' or 'surrogate' objective functions."
             "If 'None', either 'func' or 'surrogates' must not be 'None'."
         ),
@@ -857,7 +905,7 @@ class Objective(BaseModel):
 class Constraint(BaseModel):
     """Model for a constraint function."""
 
-    model_config = ConfigDict(frozen=True, from_attributes=True)
+    model_config = ConfigDict(frozen=True, from_attributes=True, extra="forbid")
 
     name: str = Field(
         description=(
@@ -903,7 +951,7 @@ class Constraint(BaseModel):
     function must match objective/variable/constant symbols.
     Can be 'None' if either 'simulator_path' or 'surrogates' is not 'None'.
     If 'None', either 'simulator_path' or 'surrogates' must not be 'None'."""
-    simulator_path: Path | None = Field(
+    simulator_path: Path | Url | None = Field(
         description=(
             "Path to a python file with the connection to simulators. Must be a valid Path."
             "Can be 'None' for if either 'func' or 'surrogates' is not 'None'."
@@ -960,7 +1008,7 @@ class DiscreteRepresentation(BaseModel):
     found at `objective_values['f_i'][j]` for all `i` and some `j`.
     """
 
-    model_config = ConfigDict(frozen=True, from_attributes=True)
+    model_config = ConfigDict(frozen=True, from_attributes=True, extra="forbid")
 
     variable_values: dict[str, list[VariableType]] = Field(
         description=(
@@ -999,7 +1047,7 @@ class DiscreteRepresentation(BaseModel):
 class Problem(BaseModel):
     """Model for a problem definition."""
 
-    model_config = ConfigDict(frozen=True)
+    model_config = ConfigDict(frozen=True, extra="forbid")
 
     _scalarization_index: int = PrivateAttr(default=1)
     # TODO: make init to communicate the _scalarization_index to a new model
@@ -1017,7 +1065,6 @@ class Problem(BaseModel):
             is_convex=db_instance.is_convex,
             is_linear=db_instance.is_linear,
             is_twice_differentiable=db_instance.is_twice_differentiable,
-            variable_domain=db_instance.variable_domain,
             scenario_keys=db_instance.scenario_keys,
             constants=constants if constants != [] else None,
             variables=[Variable.model_validate(var) for var in db_instance.variables]
@@ -1564,7 +1611,7 @@ class Problem(BaseModel):
 
         """
         json_content = self.model_dump_json(indent=4)
-        path.write_text(json_content)
+        path.write_text(json_content, encoding="utf-8")
 
     @classmethod
     def load_json(cls, path: Path) -> "Problem":
@@ -1578,33 +1625,7 @@ class Problem(BaseModel):
         """
         json_data = path.read_text()
 
-        return cls.model_validate_json(json_data)
-
-    @model_validator(mode="after")
-    def set_is_twice_differentiable(cls, values):
-        """If "is_twice_differentiable" is explicitly provided to the model, we set it to that value."""
-        if "is_twice_differentiable" in values and values["is_twice_differentiable"] is not None:
-            values["is_twice_differentiable_"] = values["is_twice_differentiable"]
-
-        return values
-
-    @model_validator(mode="after")
-    @classmethod
-    def set_is_linear(cls, values):
-        """If "is_linear" is explicitly provided to the model, we set it to that value."""
-        if "is_linear" in values and values["is_linear"] is not None:
-            values["is_linear_"] = values["is_linear"]
-
-        return values
-
-    @model_validator(mode="after")
-    @classmethod
-    def set_is_convex(cls, values):
-        """If "is_convex" is explicitly provided to the model, we set it to that value."""
-        if "is_convex" in values and values["is_convex"] is not None:
-            values["is_convex_"] = values["is_convex"]
-
-        return values
+        return cls.model_validate_json(json_data, by_name=True)
 
     name: str = Field(
         description="Name of the problem.",

desdeo/problem/simulator_evaluator.py

@@ -5,29 +5,38 @@ import subprocess
 import sys
 from inspect import getfullargspec
 from pathlib import Path
+from urllib.parse import urlparse
 
 import joblib
 import numpy as np
 import polars as pl
-# import skops.io as sio
+import requests
 
 from desdeo.problem import (
+    MathParser,
     ObjectiveTypeEnum,
     PolarsEvaluator,
     PolarsEvaluatorModesEnum,
     Problem,
 )
+from desdeo.problem.external import ProviderParams, get_resolver, supported_schemes
+
+# external resolver to resolve providers for problems defined externally of DESDEO
+_external_resolver = get_resolver()
 
 
 class EvaluatorError(Exception):
     """Error raised when exceptions are encountered in an Evaluator."""
 
 
-class Evaluator:
+class SimulatorEvaluator:
     """A class for creating evaluators for simulator based and surrogate based objectives, constraints and extras."""
 
-    def __init__(
-        self, problem: Problem, params: dict[str, dict] | None = None, surrogate_paths: dict[str, Path] | None = None
+    def __init__(  # noqa: PLR0912
+        self,
+        problem: Problem,
+        params: dict[str, dict] | ProviderParams | None = None,
+        surrogate_paths: dict[str, Path] | None = None,
     ):
         """Creating an evaluator for simulator based and surrogate based objectives, constraints and extras.
 
@@ -62,6 +71,15 @@ class Evaluator:
             obj.symbol
             for obj in list(filter(lambda x: x.objective_type == ObjectiveTypeEnum.surrogate, problem.objectives))
         ]
+        if problem.scalarization_funcs is not None:
+            parser = MathParser()
+            self.scalarization_funcs = [
+                (func.symbol, parser.parse(func.func))
+                for func in problem.scalarization_funcs
+                if func.symbol is not None
+            ]
+        else:
+            self.scalarization_funcs = []
         # Gather any constraints' symbols
         if problem.constraints is not None:
             self.analytical_symbols = self.analytical_symbols + [
@@ -93,7 +111,10 @@ class Evaluator:
 
         # Gather the possible simulators
         self.simulators = problem.simulators if problem.simulators is not None else []
+
         # Gather the possibly given parameters
+        if params and not isinstance(params, dict):
+            params = params.model_dump()
         self.params = {}
         for sim in self.simulators:
             sim_params = params.get(sim.name, {}) if params is not None else {}
@@ -136,15 +157,37 @@ class Evaluator:
         for sim in self.simulators:
             # gather the possible parameters for the simulator
             params = self.params.get(sim.name, {})
-            # call the simulator with the decision variable values and parameters as dicts
-            res = subprocess.run(
-                [sys.executable, sim.file, "-d", str(xs), "-p", str(params)], capture_output=True, text=True
-            )
-            if res.returncode == 0:
-                # gather the simulation results (a dict) into the results dataframe
-                res_df = res_df.hstack(pl.DataFrame(json.loads(res.stdout)))
-            else:
-                raise EvaluatorError(res.stderr)
+            if sim.file is not None:
+                # call the simulator with the decision variable values and parameters as dicts
+                res = subprocess.run(
+                    [sys.executable, sim.file, "-d", str(xs), "-p", str(params)], capture_output=True, text=True
+                )
+                if res.returncode == 0:
+                    # gather the simulation results (a dict) into the results dataframe
+                    res_df = res_df.hstack(pl.DataFrame(json.loads(res.stdout)))
+                else:
+                    raise EvaluatorError(res.stderr)
+            elif sim.url is not None:
+                # call the endpoint
+                try:
+                    if isinstance(xs, pl.DataFrame):
+                        # if xs is a polars dataframe, convert it to a dict
+                        xs = xs.to_dict(as_series=False)
+                    scheme = urlparse(sim.url.url).scheme
+                    if scheme in supported_schemes:
+                        # desdeo
+                        res = _external_resolver.evaluate(sim.url.url, params, xs)
+                        res_df = res_df.hstack(pl.DataFrame(res))
+                        # parse res
+                    else:
+                        # http, https, etc...
+                        res = requests.get(sim.url.url, auth=sim.url.auth, json={"d": xs, "p": params})
+                        res.raise_for_status()  # raise an error if the request failed
+                        res_df = res_df.hstack(pl.DataFrame(res.json()))
+                except requests.RequestException as e:
+                    raise EvaluatorError(
+                        f"Failed to call the simulator at {sim.url}. Is the simulator server running?"
+                    ) from e
 
         # Evaluate the minimization form of the objective functions
         min_obj_columns = pl.DataFrame()
@@ -153,7 +196,11 @@ class Evaluator:
                 min_obj_columns = min_obj_columns.hstack(
                     res_df.select((min_max_mult * pl.col(f"{symbol}")).alias(f"{symbol}_min"))
                 )
-        return res_df.hstack(min_obj_columns)
+
+        res_df = res_df.hstack(min_obj_columns)
+        # If there are scalarization functions, evaluate them as well
+        scalarization_columns = res_df.select(*[expr.alias(symbol) for symbol, expr in self.scalarization_funcs])
+        return res_df.hstack(scalarization_columns)
 
     def _evaluate_surrogates(self, xs: dict[str, list[int | float]]) -> pl.DataFrame:
         """Evaluate the problem for the given decision variables using the surrogate models.
@@ -194,7 +241,10 @@ class Evaluator:
                 min_obj_columns = min_obj_columns.hstack(
                     res.select((min_max_mult * pl.col(f"{symbol}")).alias(f"{symbol}_min"))
                 )
-        return res.hstack(min_obj_columns)
+        res_df = res.hstack(min_obj_columns)
+        # If there are scalarization functions, evaluate them as well
+        scalarization_columns = res_df.select(*[expr.alias(symbol) for symbol, expr in self.scalarization_funcs])
+        return res_df.hstack(scalarization_columns)
 
     def _load_surrogates(self, surrogate_paths: dict[str, Path] | None = None):
         """Load the surrogate models from disk and store them within the evaluator.

desdeo/problem/testproblems/__init__.py

@@ -4,15 +4,21 @@ Pre-defined problems for, e.g.,
 testing and illustration purposed are defined here.
 """
 
-__all__ = [
+__all__ = [  # noqa: RUF022
     "binh_and_korn",
     "dtlz2",
     "forest_problem",
     "forest_problem_discrete",
-    "simple_knapsack",
-    "simple_knapsack_vectors",
+    "mcwb_equilateral_tbeam_problem",
+    "mcwb_hollow_rectangular_problem",
+    "mcwb_ragsdell1976_problem",
+    "mcwb_solid_rectangular_problem",
+    "mcwb_square_channel_problem",
+    "mcwb_tapered_channel_problem",
+    "mixed_variable_dimensions_problem",
     "momip_ti2",
     "momip_ti7",
+    "multi_valued_constraint_problem",
     "nimbus_test_problem",
     "pareto_navigator_test_problem",
     "re21",
@@ -22,8 +28,11 @@ __all__ = [
     "river_pollution_problem",
     "river_pollution_problem_discrete",
     "river_pollution_scenario",
+    "rocket_injector_design",
     "simple_data_problem",
     "simple_integer_test_problem",
+    "simple_knapsack",
+    "simple_knapsack_vectors",
     "simple_linear_test_problem",
     "simple_scenario_test_problem",
     "simple_test_problem",
@@ -33,22 +42,32 @@ __all__ = [
     "zdt1",
     "zdt2",
     "zdt3",
-    "rocket_injector_design",
-    "mixed_variable_dimensions_problem",
-    "mcwb_solid_rectangular_problem"
+    "best_cake_problem",
+    "dmitry_forest_problem_disc",
 ]
 
 
 from .binh_and_korn_problem import binh_and_korn
+from .cake_problem import best_cake_problem
+from .dmitry_forest_problem_discrete import dmitry_forest_problem_disc
 from .dtlz2_problem import dtlz2
 from .forest_problem import forest_problem, forest_problem_discrete
 from .knapsack_problem import simple_knapsack, simple_knapsack_vectors
+from .mcwb_problem import (
+    mcwb_equilateral_tbeam_problem,
+    mcwb_hollow_rectangular_problem,
+    mcwb_ragsdell1976_problem,
+    mcwb_solid_rectangular_problem,
+    mcwb_square_channel_problem,
+    mcwb_tapered_channel_problem,
+)
 from .mixed_variable_dimenrions_problem import mixed_variable_dimensions_problem
 from .momip_problem import momip_ti2, momip_ti7
+from .multi_valued_constraints import multi_valued_constraint_problem
 from .nimbus_problem import nimbus_test_problem
 from .pareto_navigator_problem import pareto_navigator_test_problem
 from .re_problem import re21, re22, re23, re24
-from .river_pollution_problem import (
+from .river_pollution_problems import (
     river_pollution_problem,
     river_pollution_problem_discrete,
     river_pollution_scenario,
@@ -67,7 +86,3 @@ from .spanish_sustainability_problem import (
     spanish_sustainability_problem_discrete,
 )
 from .zdt_problem import zdt1, zdt2, zdt3
-
-from .mcwb_problem import (mcwb_solid_rectangular_problem, mcwb_hollow_rectangular_problem,
-                           mcwb_equilateral_tbeam_problem, mcwb_square_channel_problem, mcwb_tapered_channel_problem,
-                           mcwb_ragsdell1976_problem)

desdeo/problem/testproblems/benchmarks_server.py

@@ -0,0 +1,120 @@
+# A FastAPI server to expose pymoo benchmark problems
+from typing import Any
+
+import polars as pl
+import requests
+from fastapi import FastAPI
+from pydantic import BaseModel
+from pymoo.problems import get_problem
+
+from desdeo.problem.schema import Objective, Problem, Simulator, Url, Variable
+
+
+class PymooParameters(BaseModel):
+    """Parameters for a pymoo problem instance."""
+
+    name: str
+    n_var: int
+    n_obj: int
+    minus: bool = False
+
+
+class ProblemInfo(BaseModel):
+    """Information about a pymoo problem instance."""
+
+    lower_bounds: dict[str, float]
+    """Lower bounds of the decision variables. Keys are the names of the decision variables, e.g. "x_1", "x_2", etc."""
+    upper_bounds: dict[str, float]
+    """Upper bounds of the decision variables."""
+    objective_names: list[str]
+
+
+app = FastAPI()
+
+
+def get_pymoo_problem(p: PymooParameters):
+    """Get a pymoo problem instance by name, number of variables, and number of objectives."""
+    params = p.model_dump()
+    params.pop("minus")
+    return get_problem(**params)
+
+
+@app.get("/evaluate")
+def evaluate(d: dict[str, list[float]], p: PymooParameters) -> dict[str, Any]:
+    """Evaluate a pymoo problem instance with given parameters and input values."""
+    problem = get_pymoo_problem(p)
+
+    xs_df = pl.DataFrame(d)
+
+    output = problem.evaluate(xs_df.to_numpy())
+    output_df = pl.DataFrame(output, schema=[f"f_{i + 1}" for i in range(problem.n_obj)])
+
+    return d | output_df.to_dict(as_series=False)
+
+
+@app.get("/info")
+def info(p: PymooParameters) -> ProblemInfo:
+    """Get information about a pymoo problem instance, including bounds and objective names."""
+    problem = get_pymoo_problem(p)
+    bounds = problem.bounds()
+
+    return ProblemInfo(
+        lower_bounds={f"x_{i + 1}": bounds[0][i] for i in range(problem.n_var)},
+        upper_bounds={f"x_{i + 1}": bounds[1][i] for i in range(problem.n_var)},
+        objective_names=[f"f_{i + 1}" for i in range(problem.n_obj)],
+    )
+
+
+url = "http://127.0.0.1"
+port = 8000
+
+
+def server_problem(parameters: PymooParameters) -> Problem:
+    """Create a Problem instance from pymoo parameters."""
+    try:
+        info = requests.get(url + f":{port}/info", json=parameters.model_dump())
+        info.raise_for_status()
+    except requests.RequestException as e:
+        raise RuntimeError("Failed to fetch problem info. Is the server running?") from e
+    info: ProblemInfo = ProblemInfo.model_validate(info.json())
+
+    simulator_url = Url(url=f"{url}:{port}/evaluate")
+
+    return Problem(
+        name=parameters.name,
+        description=f"Problem {parameters.name} with {parameters.n_var} variables and {parameters.n_obj} objectives.",
+        variables=[
+            Variable(
+                name=f"x_{i + 1}",
+                symbol=f"x_{i + 1}",
+                lowerbound=info.lower_bounds[f"x_{i + 1}"],
+                upperbound=info.upper_bounds[f"x_{i + 1}"],
+                variable_type="real",
+            )
+            for i in range(parameters.n_var)
+        ],
+        objectives=[
+            Objective(
+                name=f"f_{i + 1}",
+                symbol=f"f_{i + 1}",
+                simulator_path=simulator_url,
+                objective_type="simulator",
+                maximize=parameters.minus,
+            )
+            for i in range(parameters.n_obj)
+        ],
+        simulators=[
+            Simulator(
+                name="s1",
+                symbol="s1",
+                url=simulator_url,
+                parameter_options=parameters.model_dump(),
+            )
+        ],
+    )
+
+
+if __name__ == "__main__":
+    import uvicorn
+
+    uvicorn.run(app)