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

desdeo/api/routers/utopia.py

@@ -4,9 +4,8 @@ import json
 from typing import Annotated
 
 from fastapi import APIRouter, Depends
-from sqlmodel import Session, select
+from sqlmodel import select
 
-from desdeo.api.db import get_session
 from desdeo.api.models import (
     ForestProblemMetaData,
     NIMBUSFinalState,
@@ -14,33 +13,33 @@ from desdeo.api.models import (
     NIMBUSSaveState,
     ProblemMetaDataDB,
     StateDB,
-    User,
     UtopiaRequest,
     UtopiaResponse,
 )
-from desdeo.api.routers.user_authentication import get_current_user
+from desdeo.api.routers.utils import SessionContext, get_session_context
 
 router = APIRouter(prefix="/utopia")
 
 
 @router.post("/")
-def get_utopia_data(
+def get_utopia_data(  # noqa: C901
     request: UtopiaRequest,
-    user: Annotated[User, Depends(get_current_user)],
-    session: Annotated[Session, Depends(get_session)],
+    context: Annotated[SessionContext, Depends(get_session_context)],
 ) -> UtopiaResponse:
     """Request and receive the Utopia map corresponding to the decision variables sent.
 
     Args:
         request (UtopiaRequest): the set of decision variables and problem for which the utopia forest map is requested
-        for.
-        user (Annotated[User, Depend(get_current_user)]) the current user
-        session (Annotated[Session, Depends(get_session)]) the current database session
+            for.
+        context (Annotated[SessionContext, Depends(get_session_context)]): the current session context
+
     Raises:
         HTTPException:
     Returns:
         UtopiaResponse: the map for the forest, to be rendered in frontend
     """
+    session = context.db_session
+
     empty_response = UtopiaResponse(is_utopia=False, map_name="", map_json={}, options={}, description="", years=[])
 
     state = session.exec(select(StateDB).where(StateDB.id == request.solution.state_id)).first()
@@ -105,9 +104,9 @@ def get_utopia_data(
         # The dict keys get converted to ints to strings when it's loaded from database
         try:
             treatments = forest_metadata.schedule_dict[key][str(decision_variables[key].index(1))]
-        except ValueError as e:
+        except ValueError:
             # if the optimization didn't choose any decision alternative, it's safe to assume
-            #  that nothing is being done at that forest stand
+            # that nothing is being done at that forest stand
             treatments = forest_metadata.schedule_dict[key]["0"]
             # print(e)
         treatments_dict[key] = {forest_metadata.years[0]: 0, forest_metadata.years[1]: 0, forest_metadata.years[2]: 0}

desdeo/api/tests/test_routes.py

@@ -110,6 +110,7 @@ def test_refresh(client: TestClient):
     response_refresh = client.post("/refresh")
 
     assert "access_token" in response_refresh.json()
+    assert "access_token" in response_refresh.cookies
 
     assert response_good.json()["access_token"] != response_refresh.json()["access_token"]
 
@@ -649,7 +650,7 @@ def test_nimbus_save_and_delete_save(client: TestClient):
     assert len(solve_result.saved_solutions) > 0
 
     # 4. Delete save
-    request: NIMBUSDeleteSaveRequest = NIMBUSDeleteSaveRequest(state_id=2, solution_index=1)
+    request: NIMBUSDeleteSaveRequest = NIMBUSDeleteSaveRequest(state_id=2, solution_index=1, problem_id=1)
     response = post_json(client, "/method/nimbus/delete_save", request.model_dump(), access_token)
     delete_save_result: NIMBUSDeleteSaveResponse = NIMBUSDeleteSaveResponse.model_validate(json.loads(response.content))
 
@@ -930,9 +931,9 @@ def test_preferred_solver(client: TestClient):
         response = post_json(client, "/method/nimbus/initialize", request.model_dump(), access_token)
         model = NIMBUSInitializationResponse.model_validate(response.json())
     except Exception as e:
-        print(e)
-        print("^ This outcome is expected since pyomo_cbc doesn't support nonlinear problems.")
-        print("  As that solver is what we set it to be in the start, we can verify that they actually get used.")
+        print(e)  # noqa: T201
+        print("^ This outcome is expected since pyomo_cbc doesn't support nonlinear problems.")  # noqa: T201
+        print("  As that solver is what we set it to be in the start, we can verify that they actually get used.")  # noqa: T201
 
 
 def test_get_available_solvers(client: TestClient):
@@ -1027,7 +1028,7 @@ def test_gdm_score_bands(client: TestClient):
     response = post_json(client=client, endpoint="/gdm/add_to_group", json=req, access_token=access_token)
     assert response.status_code == 200
 
-    access_token = login(client=client, username="dm", password="dm")
+    access_token = login(client=client, username="dm", password="dm")  # noqa: S106
 
     # Now we have a group, so let's get on with making stuff with gdm score bands.
     req = GDMScoreBandsInitializationRequest(

desdeo/emo/__init__.py

@@ -42,6 +42,7 @@ from .options.generator import (
     RandomGeneratorOptions,
     RandomIntegerGeneratorOptions,
     RandomMixedIntegerGeneratorOptions,
+    SeededHybridGeneratorOptions,
 )
 from .options.mutation import (
     BinaryFlipMutationOptions,
@@ -131,6 +132,7 @@ generator = SimpleNamespace(
     RandomGeneratorOptions=RandomGeneratorOptions,
     RandomIntegerGeneratorOptions=RandomIntegerGeneratorOptions,
     RandomMixedIntegerGeneratorOptions=RandomMixedIntegerGeneratorOptions,
+    SeededHybridGeneratorOptions=SeededHybridGeneratorOptions,
 )
 
 templates = SimpleNamespace(

desdeo/emo/operators/__init__.py

@@ -1 +1 @@
-
+"""Exports of the 'operators' module."""

desdeo/emo/operators/generator.py

@@ -383,7 +383,7 @@ class ArchiveGenerator(BaseGenerator):
         publisher: Publisher,
         verbosity: int,
         solutions: pl.DataFrame,
-        **kwargs,  # just to dump seed
+        **kwargs: dict,  # just to dump seed
     ):
         """Initialize the ArchiveGenerator class.
 
@@ -395,10 +395,11 @@ class ArchiveGenerator(BaseGenerator):
             verbosity (int): The verbosity level of the generator. A verbosity of 2 is needed if you want to maintain
                 an external archive. Otherwise, a verbosity of 1 is sufficient.
             solutions (pl.DataFrame): The decision variable vectors to use as the initial population.
+            kwargs (dict): Other keyword arguments to pass, e.g., a random seed.
         """
         super().__init__(problem, verbosity=verbosity, publisher=publisher)
         if not isinstance(solutions, pl.DataFrame):
-            raise ValueError("The solutions must be a polars DataFrame.")
+            raise TypeError("The solutions must be a polars DataFrame.")
         if solutions.shape[0] == 0:
             raise ValueError("The solutions DataFrame is empty.")
         self.solutions = solutions
@@ -457,3 +458,153 @@ class ArchiveGenerator(BaseGenerator):
 
     def update(self, message) -> None:
         """Update the generator based on the message."""
+
+
+class SeededHybridGenerator(BaseGenerator):
+    """Generates an initial population using a mix of seeded, perturbed, and random solutions."""
+
+    def __init__(
+        self,
+        problem,
+        evaluator,
+        publisher,
+        verbosity,
+        seed: int,
+        n_points: int,
+        seed_solution: pl.DataFrame,
+        perturb_fraction: float = 0.2,
+        sigma: float = 0.02,
+        flip_prob: float = 0.1,
+    ):
+        """Initialize the seeded hybrid generator.
+
+        The generator always includes the provided seed solution in the initial
+        population, fills a fraction of the population with small perturbations
+        around the seed, and fills the remainder with randomly generated solutions.
+
+        Args:
+            problem (Problem): The optimization problem.
+            evaluator (EMOEvaluator): Evaluator used to compute objectives and constraints.
+            publisher (Publisher): Publisher used for emitting generator messages.
+            verbosity (int): Verbosity level of the generator.
+            seed (int): Seed used for random number generation.
+            n_points (int): Total size of the initial population.
+            seed_solution (pl.DataFrame): A single-row DataFrame containing a seed
+                decision variable vector.
+            perturb_fraction (float, optional): Fraction of the population generated
+                by perturbing the seed solution. Defaults to 0.2.
+            sigma (float, optional): Relative perturbation scale with respect to
+                variable ranges. Defaults to 0.02.
+            flip_prob (float, optional): Probability of flipping a binary variable
+                when perturbing the seed. Defaults to 0.1.
+
+        Raises:
+            TypeError: If ``seed_solution`` is not a polars DataFrame.
+            ValueError: If ``seed_solution`` does not contain exactly one row.
+            ValueError: If ``seed_solution`` columns do not match problem variables.
+            ValueError: If ``n_points`` is not positive.
+            ValueError: If ``perturb_fraction`` is outside ``[0, 1]``.
+            ValueError: If ``sigma`` is negative.
+            ValueError: If ``flip_prob`` is outside ``[0, 1]``.
+        """
+        super().__init__(problem, verbosity=verbosity, publisher=publisher)
+
+        if not isinstance(seed_solution, pl.DataFrame):
+            raise TypeError("seed_solution must be a polars DataFrame.")
+        if seed_solution.shape[0] != 1:
+            raise ValueError("seed_solution must have exactly one row.")
+        if set(seed_solution.columns) != set(self.variable_symbols):
+            raise ValueError("seed_solution columns must match problem variables.")
+
+        if n_points <= 0:
+            raise ValueError("n_points must be > 0.")
+        if not (0.0 <= perturb_fraction <= 1.0):
+            raise ValueError("perturb_fraction must be in [0, 1].")
+        if sigma < 0:
+            raise ValueError("sigma must be >= 0.")
+        if not (0.0 <= flip_prob <= 1.0):
+            raise ValueError("flip_prob must be in [0, 1].")
+
+        self.n_points = n_points
+        self.seed_solution = seed_solution
+        self.perturb_fraction = perturb_fraction
+        self.sigma = sigma
+        self.flip_prob = flip_prob
+
+        self.evaluator = evaluator
+        self.seed = seed
+        self.rng = np.random.default_rng(self.seed)
+
+        self.population = None
+        self.out = None
+
+    def _random_population(self, n: int) -> pl.DataFrame:
+        tmp = {}
+        for var in self.problem.variables:
+            if var.variable_type in [VariableTypeEnum.binary, VariableTypeEnum.integer]:
+                vals = self.rng.integers(var.lowerbound, var.upperbound, size=n, endpoint=True).astype(float)
+            else:
+                vals = self.rng.uniform(var.lowerbound, var.upperbound, size=n).astype(float)
+            tmp[var.symbol] = vals
+        return pl.DataFrame(tmp)
+
+    def _perturb_seed(self, n: int) -> pl.DataFrame:
+        # includes the exact seed as first row
+        seed_row = self.seed_solution.select(self.variable_symbols).to_dict(as_series=False)
+        seed_vals = {k: float(v[0]) for k, v in seed_row.items()}
+
+        rows = [seed_vals]  # ensure seed present
+        if n <= 1:
+            return pl.DataFrame(rows)
+
+        for _ in range(n - 1):
+            x = {}
+            for var in self.problem.variables:
+                lb, ub = float(var.lowerbound), float(var.upperbound)
+                r = ub - lb
+
+                v0 = seed_vals[var.symbol]
+
+                if var.variable_type == VariableTypeEnum.binary:
+                    v = 1.0 - v0 if self.rng.random() < self.flip_prob else v0
+                elif var.variable_type == VariableTypeEnum.integer:
+                    # scales integer nose
+                    step = max(1, round(self.sigma * r)) if r >= 1 else 0
+                    dv = self.rng.integers(-step, step + 1) if step > 0 else 0
+                    v = float(int(np.clip(round(v0 + dv), lb, ub)))
+                else:
+                    # continuous noise is proportional to range
+                    dv = self.rng.normal(0.0, self.sigma * r if r > 0 else 0.0)
+                    v = float(np.clip(v0 + dv, lb, ub))
+
+                x[var.symbol] = v
+            rows.append(x)
+
+        return pl.DataFrame(rows)
+
+    def do(self) -> tuple[pl.DataFrame, pl.DataFrame]:
+        """Generate a population.
+
+        Returns:
+            tuple[pl.DataFrame, pl.DataFrame]: the population.
+        """
+        if self.population is not None and self.out is not None:
+            self.notify()
+            return self.population, self.out
+
+        n_pert = max(1, round(self.perturb_fraction * self.n_points))
+        n_pert = min(n_pert, self.n_points)
+        n_rand = self.n_points - n_pert
+
+        pert = self._perturb_seed(n_pert)
+        rand = self._random_population(n_rand) if n_rand > 0 else pl.DataFrame({s: [] for s in self.variable_symbols})
+
+        self.population = pl.concat([pert, rand], how="vertical")
+
+        self.out = self.evaluator.evaluate(self.population)
+        self.notify()
+
+        return self.population, self.out
+
+    def update(self, message) -> None:
+        """Update the generator based on the message."""

desdeo/emo/options/__init__.py

@@ -1,3 +1,5 @@
+"""Exports of the 'options' module."""
+
 from .crossover import (
     BlendAlphaCrossoverOptions,
     BoundedExponentialCrossoverOptions,
@@ -17,6 +19,7 @@ from .generator import (
     RandomGeneratorOptions,
     RandomIntegerGeneratorOptions,
     RandomMixedIntegerGeneratorOptions,
+    SeededHybridGeneratorOptions,
     generator_constructor,
 )
 from .mutation import (
@@ -105,4 +108,5 @@ __all__ = [  # noqa: RUF022
     "selection_constructor",
     "RepairOptions",
     "repair_constructor",
+    "SeededHybridGeneratorOptions",
 ]

desdeo/emo/options/generator.py

@@ -16,6 +16,7 @@ from desdeo.emo.operators.generator import (
     RandomGenerator,
     RandomIntegerGenerator,
     RandomMixedIntegerGenerator,
+    SeededHybridGenerator,
 )
 
 if TYPE_CHECKING:
@@ -85,6 +86,27 @@ class ArchiveGeneratorOptions(BaseModel):
     outputs: pl.DataFrame
     """The corresponding outputs of the initial solutions."""
 
+
+class SeededHybridGeneratorOptions(BaseGeneratorOptions):
+    """Options for the seeded hybrid generator."""
+
+    name: Literal["SeededHybridGenerator"] = Field(default="SeededHybridGenerator", frozen=True)
+    model_config = {"arbitrary_types_allowed": True, "use_attribute_docstrings": True}
+
+    seed_solution: pl.DataFrame
+    """A dataframe with a single row representing the solution seed. The columns
+    must math the symbols of the variables in the problem being solved.
+    """
+    perturb_fraction: float = Field(default=0.2, ge=0.0, le=1.0)
+    """The desired fraction of perturbed vs random solutions in the generated population."""
+
+    sigma: float = Field(default=0.02, ge=0.0)
+    """The relative perturbation scale with respect to variable ranges."""
+
+    flip_prob: float = Field(default=0.1, ge=0.0, le=1.0)
+    """The flipping probability when perturbing binary variables."""
+
+
 GeneratorOptions = (
     LHSGeneratorOptions
     | RandomBinaryGeneratorOptions
@@ -92,6 +114,7 @@ GeneratorOptions = (
     | RandomIntegerGeneratorOptions
     | RandomMixedIntegerGeneratorOptions
     | ArchiveGeneratorOptions
+    | SeededHybridGeneratorOptions
 )
 
 
@@ -123,6 +146,7 @@ def generator_constructor(
         "RandomIntegerGenerator": RandomIntegerGenerator,
         "RandomMixedIntegerGenerator": RandomMixedIntegerGenerator,
         "ArchiveGenerator": ArchiveGenerator,
+        "SeededHybridGenerator": SeededHybridGenerator,
     }
     options: dict = options.model_dump()
     name = options.pop("name")

desdeo/problem/__init__.py

@@ -7,35 +7,36 @@ __all__ = [
     "DiscreteRepresentation",
     "Evaluator",
     "ExtraFunction",
-    "flatten_variable_dict",
     "FormatEnum",
     "GurobipyEvaluator",
-    "get_nadir_dict",
-    "get_ideal_dict",
     "InfixExpressionParser",
     "MathParser",
-    "numpy_array_to_objective_dict",
-    "objective_dict_to_numpy_array",
     "Objective",
     "ObjectiveTypeEnum",
-    "Problem",
-    "PyomoEvaluator",
-    "SympyEvaluator",
-    "tensor_constant_from_dataframe",
     "PolarsEvaluator",
     "PolarsEvaluatorModesEnum",
+    "Problem",
+    "PyomoEvaluator",
     "ScalarizationFunction",
     "Simulator",
+    "SimulatorEvaluator",
+    "SympyEvaluator",
+    "Tensor",
     "TensorConstant",
     "TensorVariable",
     "Url",
-    "unflatten_variable_array",
     "Variable",
     "VariableDimensionEnum",
     "VariableDomainTypeEnum",
     "VariableType",
-    "Tensor",
     "VariableTypeEnum",
+    "flatten_variable_dict",
+    "get_ideal_dict",
+    "get_nadir_dict",
+    "numpy_array_to_objective_dict",
+    "objective_dict_to_numpy_array",
+    "tensor_constant_from_dataframe",
+    "unflatten_variable_array",
     "variable_dimension_enumerate",
 ]
 

desdeo/problem/evaluator.py

@@ -33,7 +33,7 @@ class PolarsEvaluatorModesEnum(str, Enum):
     mixed = "mixed"
     """Indicates that the problem has analytical and simulator and/or surrogate
     based objectives, constraints and extra functions. In this mode, the evaluator
-    only handles data-based and analytical functions. For data-bsed objectives,
+    only handles data-based and analytical functions. For data-based objectives,
     it assumes that the variables are to be evaluated by finding the closest
     variables values in the data compare to the input, and evaluating the result
     to be the matching objective function values that match to the closest
@@ -74,7 +74,7 @@ def variable_dimension_enumerate(problem: Problem) -> VariableDimensionEnum:
     enum = VariableDimensionEnum.scalar
     for var in problem.variables:
         if isinstance(var, TensorVariable):
-            if len(var.shape) == 1 or len(var.shape) == 2 and not (var.shape[0] > 1 and var.shape[1] > 1):  # noqa: PLR2004
+            if len(var.shape) == 1 or (len(var.shape) == 2 and not (var.shape[0] > 1 and var.shape[1] > 1)):  # noqa: PLR2004
                 enum = VariableDimensionEnum.vector
             else:
                 return VariableDimensionEnum.tensor
@@ -187,7 +187,7 @@ class PolarsEvaluator:
                 f"Provided 'evaluator_mode' {evaluator_mode} not supported. Must be one of {PolarsEvaluatorModesEnum}."
             )
 
-    def _polars_init(self):  # noqa: C901, PLR0912
+    def _polars_init(self):  # noqa: C901
         """Initialization of the evaluator for parser type 'polars'."""
         # If any constants are defined in problem, replace their symbol with the defined numerical
         # value in all the function expressions found in the Problem.
@@ -211,8 +211,7 @@ class PolarsEvaluator:
                     parsed_obj_funcs[f"{obj.symbol}"] = None
                 else:
                     msg = (
-                        f"Incorrect objective-type {obj.objective_type} encountered. "
-                        f"Must be one of {ObjectiveTypeEnum}"
+                        f"Incorrect objective-type {obj.objective_type} encountered. Must be one of {ObjectiveTypeEnum}"
                     )
                     raise PolarsEvaluatorError(msg)
 

desdeo/problem/gurobipy_evaluator.py

@@ -1,8 +1,8 @@
 """Defines an evaluator compatible with the Problem JSON format and transforms it into a GurobipyModel."""
 
+import warnings
 from operator import eq as _eq
 from operator import le as _le
-import warnings
 
 import gurobipy as gp
 import numpy as np
@@ -18,8 +18,7 @@ from desdeo.problem.schema import (
     TensorConstant,
     TensorVariable,
     Variable,
-    VariableTypeEnum
-
+    VariableTypeEnum,
 )
 
 
@@ -125,8 +124,16 @@ class GurobipyEvaluator:
 
             elif isinstance(var, TensorVariable):
                 # handle tensor variables, i.e., vectors etc..
-                lowerbounds = var.get_lowerbound_values() if var.lowerbounds is not None else np.full(var.shape, float("-inf")).tolist()
-                upperbounds = var.get_upperbound_values() if var.upperbounds is not None else np.full(var.shape, float("inf")).tolist()
+                lowerbounds = (
+                    var.get_lowerbound_values()
+                    if var.lowerbounds is not None
+                    else np.full(var.shape, float("-inf")).tolist()
+                )
+                upperbounds = (
+                    var.get_upperbound_values()
+                    if var.upperbounds is not None
+                    else np.full(var.shape, float("inf")).tolist()
+                )
 
                 # figure out the variable type
                 match var.variable_type:
@@ -143,13 +150,18 @@ class GurobipyEvaluator:
                         raise GurobipyEvaluatorError(msg)
 
                 # add the variable to the model
-                gvar = self.model.addMVar(shape=tuple(var.shape), lb=np.array(lowerbounds), ub=np.array(upperbounds), vtype=domain, name=var.symbol)
+                gvar = self.model.addMVar(
+                    shape=tuple(var.shape),
+                    lb=np.array(lowerbounds),
+                    ub=np.array(upperbounds),
+                    vtype=domain,
+                    name=var.symbol,
+                )
                 # set the initial value, if one has been defined
                 if var.initial_values is not None:
                     gvar.setAttr("Start", np.array(var.get_initial_values()))
                 self.mvars[var.symbol] = gvar
 
-
         # update the model before returning, so that other expressions can reference the variables
         self.model.update()
 
@@ -413,8 +425,16 @@ class GurobipyEvaluator:
                 gvar.setAttr("Start", var.initial_value)
         elif isinstance(var, TensorVariable):
             # handle tensor variables, i.e., vectors etc..
-            lowerbounds = var.get_lowerbound_values() if var.lowerbounds is not None else np.full(var.shape, float("-inf")).tolist()
-            upperbounds = var.get_upperbound_values() if var.upperbounds is not None else np.full(var.shape, float("inf")).tolist()
+            lowerbounds = (
+                var.get_lowerbound_values()
+                if var.lowerbounds is not None
+                else np.full(var.shape, float("-inf")).tolist()
+            )
+            upperbounds = (
+                var.get_upperbound_values()
+                if var.upperbounds is not None
+                else np.full(var.shape, float("inf")).tolist()
+            )
 
             # figure out the variable type
             match var.variable_type:
@@ -431,7 +451,13 @@ class GurobipyEvaluator:
                     raise GurobipyEvaluatorError(msg)
 
             # add the variable to the model
-            gvar = self.model.addMVar(shape=tuple(var.shape), lb=np.array(lowerbounds), ub=np.array(upperbounds), vtype=domain, name=var.symbol)
+            gvar = self.model.addMVar(
+                shape=tuple(var.shape),
+                lb=np.array(lowerbounds),
+                ub=np.array(upperbounds),
+                vtype=domain,
+                name=var.symbol,
+            )
             # set the initial value, if one has been defined
             if var.initial_values is not None:
                 gvar.setAttr("Start", np.array(var.get_initial_values()))
@@ -470,8 +496,7 @@ class GurobipyEvaluator:
                 expression = self.constants[name]
         return expression
 
-
-    def get_values(self) -> dict[str, float | int | bool | list[float] | list[int]]:   # noqa: C901
+    def get_values(self) -> dict[str, float | int | bool | list[float] | list[int]]:
         """Get the values from the Gurobipy Model in a dict.
 
         The keys of the dict will be the symbols defined in the problem utilized to initialize the evaluator.

desdeo/problem/infix_parser.py

@@ -193,7 +193,7 @@ class InfixExpressionParser:
     def _is_number_or_variable(self, c):
         return isinstance(c, int | float) or (isinstance(c, str) and c not in self.reserved_symbols)
 
-    def _to_math_json(self, parsed: list | str) -> list:  # noqa: PLR0911, PLR0912
+    def _to_math_json(self, parsed: list | str) -> list:
         """Converts a list of expressions into a MathJSON compliant format.
 
         The conversion happens recursively. Each list of recursed until a terminal character is reached.
@@ -324,18 +324,3 @@ class InfixExpressionParser:
         # simple expressions, like 'x_1', are parsed into just a string after removing any extra
         # brackets, so we add them back there in case it is needed
         return expr if isinstance(expr, list) else [expr]
-
-
-if __name__ == "__main__":
-    # Parse and convert
-    test = "(x_1 - c_2) ** 2 + x_2 ** 2 - 25"
-
-    ohh_no = "['Add', ['Negate', ['Square', ['Subtract', 'x_1', 8]]], ['Negate', ['Square', ['Add', 'x_2', 3]]], 7.7]"
-
-    to_json_parser = InfixExpressionParser(target="MathJSON")
-
-    parsed_expression = to_json_parser.parse(test)
-
-    print(f"Expresion:\n{test}")
-    print(f"Parsed:\n{to_json_parser._pre_parse(test)}")
-    print(f"MathJSON:\n{parsed_expression}")

desdeo/problem/json_parser.py

@@ -35,7 +35,7 @@ class MathParser:
     Currently only parses MathJSON to polars expressions. Pyomo WIP.
     """
 
-    def __init__(self, to_format: FormatEnum = "polars"):
+    def __init__(self, to_format: FormatEnum = "polars"):  # noqa: C901
         """Create a parser instance for parsing MathJSON notation into polars expressions.
 
         Args:
@@ -135,7 +135,7 @@ class MathParser:
                 acc = acc.to_numpy()
                 x = x.to_numpy()
 
-                if len(acc.shape) == 2 and len(x.shape) == 2:
+                if len(acc.shape) == 2 and len(x.shape) == 2:  # noqa: PLR2004
                     # Row vectors, just return the dot product, polars does not handle
                     # "column" vectors anyway
                     return pl.Series(values=np.einsum("ij,ij->i", acc, x, optimize=True))
@@ -373,7 +373,7 @@ class MathParser:
                     hasattr(x, "is_indexed")
                     and x.is_indexed()
                     and x.dim() > 0
-                    and (not hasattr(y, "is_indexed") or not y.is_indexed() or y.is_indexed() and y.dim() == 0)
+                    and (not hasattr(y, "is_indexed") or not y.is_indexed() or (y.is_indexed() and y.dim() == 0))
                 ):
                     # x is a tensor, y is scalar
                     expr = pyomo.Expression(
@@ -385,7 +385,7 @@ class MathParser:
                     hasattr(y, "is_indexed")
                     and y.is_indexed()
                     and y.dim() > 0
-                    and (not hasattr(x, "is_indexed") or not x.is_indexed() or x.is_indexed() and x.dim() == 0)
+                    and (not hasattr(x, "is_indexed") or not x.is_indexed() or (x.is_indexed() and x.dim() == 0))
                 ):
                     # y is a tensor, x is scalar
                     expr = pyomo.Expression(
@@ -534,16 +534,13 @@ class MathParser:
         def _sympy_matmul(*args):
             """Sympy matrix multiplication."""
             msg = (
-                "Matrix multiplication '@' has not been implemented for the Sympy parser yet."
-                " Feel free to contribute!"
+                "Matrix multiplication '@' has not been implemented for the Sympy parser yet. Feel free to contribute!"
             )
             raise NotImplementedError(msg)
 
         def _sympy_summation(summand):
             """Sympy matrix summation."""
-            msg = (
-                "Matrix summation 'Sum' has not been implemented for the Sympy parser yet." " Feel free to contribute!"
-            )
+            msg = "Matrix summation 'Sum' has not been implemented for the Sympy parser yet. Feel free to contribute!"
             raise NotImplementedError(msg)
 
         def _sympy_random_access(*args):
@@ -627,8 +624,7 @@ class MathParser:
 
             return _sum(summand)
             msg = (
-                "Matrix summation 'Sum' has not been implemented for the Gurobipy parser yet."
-                " Feel free to contribute!"
+                "Matrix summation 'Sum' has not been implemented for the Gurobipy parser yet. Feel free to contribute!"
             )
             raise NotImplementedError(msg)