pyoframe 0.0.5__py3-none-any.whl → 0.0.7__py3-none-any.whl

pyoframe/_arithmetic.py

@@ -106,7 +106,7 @@ def _add_expressions_core(*expressions: "Expression") -> "Expression":
 
         strat = (left.unmatched_strategy, right.unmatched_strategy)
 
-        propogate_strat = propogatation_strategies[strat]
+        propogate_strat = propogatation_strategies[strat]  # type: ignore
 
         if strat == (UnmatchedStrategy.DROP, UnmatchedStrategy.DROP):
             left_data = left.data.join(get_indices(right), how="inner", on=dims)

pyoframe/constants.py

@@ -132,8 +132,11 @@ class SolverStatus(Enum):
     def from_termination_condition(
         cls, termination_condition: "TerminationCondition"
     ) -> "SolverStatus":
-        for status in STATUS_TO_TERMINATION_CONDITION_MAP:
-            if termination_condition in STATUS_TO_TERMINATION_CONDITION_MAP[status]:
+        for (
+            status,
+            termination_conditions,
+        ) in STATUS_TO_TERMINATION_CONDITION_MAP.items():
+            if termination_condition in termination_conditions:
                 return status
         return cls("unknown")
 

pyoframe/core.py

@@ -271,7 +271,11 @@ class Set(ModelElement, SupportsMath, SupportPolarsMethodMixin):
         elif isinstance(set, Constraint):
             df = set.data.select(set.dimensions_unsafe)
         elif isinstance(set, SupportsMath):
-            df = set.to_expr().data.drop(RESERVED_COL_KEYS).unique(maintain_order=True)
+            df = (
+                set.to_expr()
+                .data.drop(RESERVED_COL_KEYS, strict=False)
+                .unique(maintain_order=True)
+            )
         elif isinstance(set, pd.Index):
             df = pl.from_pandas(pd.DataFrame(index=set).reset_index())
         elif isinstance(set, pd.DataFrame):
@@ -689,9 +693,9 @@ class Expression(ModelElement, SupportsMath, SupportPolarsMethodMixin):
             >>> import pyoframe as pf
             >>> m = pf.Model("max")
             >>> m.X = pf.Variable({"dim1": [1, 2, 3]}, ub=10)
-            >>> m.expr_1 = 2 * m.X
+            >>> m.expr_1 = 2 * m.X + 1
             >>> m.expr_2 = pf.sum(m.expr_1)
-            >>> m.objective = m.expr_2 + 3
+            >>> m.objective = m.expr_2 - 3
             >>> result = m.solve(log_to_console=False)
             >>> m.expr_1.value
             shape: (3, 2)
@@ -700,15 +704,16 @@ class Expression(ModelElement, SupportsMath, SupportPolarsMethodMixin):
             │ ---  ┆ ---      │
             │ i64  ┆ f64      │
             ╞══════╪══════════╡
-            │ 1    ┆ 20.0     │
-            │ 2    ┆ 20.0     │
-            │ 3    ┆ 20.0     │
+            │ 1    ┆ 21.0     │
+            │ 2    ┆ 21.0     │
+            │ 3    ┆ 21.0     │
             └──────┴──────────┘
             >>> m.expr_2.value
-            60.0
-            >>> m.objective.value
             63.0
         """
+        assert (
+            self._model is not None
+        ), "Expression must be added to the model to use .value"
         if self._model.result is None or self._model.result.solution is None:
             raise ValueError(
                 "Can't obtain value of expression since the model has not been solved."
@@ -716,8 +721,15 @@ class Expression(ModelElement, SupportsMath, SupportPolarsMethodMixin):
 
         df = (
             self.data.join(self._model.result.solution.primal, on=VAR_KEY, how="left")
+            .with_columns(
+                (
+                    pl.when(pl.col(VAR_KEY) == CONST_TERM)
+                    .then(1)
+                    .otherwise(pl.col(SOLUTION_KEY))
+                    * pl.col(COEF_KEY)
+                ).alias(SOLUTION_KEY)
+            )
             .drop(VAR_KEY)
-            .with_columns((pl.col(SOLUTION_KEY) * pl.col(COEF_KEY)))
             .drop(COEF_KEY)
         )
 
@@ -924,6 +936,9 @@ class Constraint(ModelElementWithId):
         The first call to this property will load the slack values from the solver (lazy loading).
         """
         if SLACK_COL not in self.data.columns:
+            assert (
+                self._model is not None
+            ), "Constraint must be added to a model to get the slack."
             if self._model.solver is None:
                 raise ValueError("The model has not been solved yet.")
             self._model.solver.load_slack()
@@ -1160,7 +1175,7 @@ class Variable(ModelElementWithId, SupportsMath, SupportPolarsMethodMixin):
         lb: float | int | SupportsToExpr | None = None,
         ub: float | int | SupportsToExpr | None = None,
         vtype: VType | VTypeValue = VType.CONTINUOUS,
-        equals: SupportsToExpr = None,
+        equals: Optional[SupportsMath] = None,
     ):
         if lb is None:
             lb = float("-inf")
@@ -1222,6 +1237,9 @@ class Variable(ModelElementWithId, SupportsMath, SupportPolarsMethodMixin):
         The first call to this property will load the reduced costs from the solver (lazy loading).
         """
         if RC_COL not in self.data.columns:
+            assert (
+                self._model is not None
+            ), "Variable must be added to a model to get the reduced cost."
             if self._model.solver is None:
                 raise ValueError("The model has not been solved yet.")
             self._model.solver.load_rc()
@@ -1245,7 +1263,7 @@ class Variable(ModelElementWithId, SupportsMath, SupportPolarsMethodMixin):
         )
 
     def to_expr(self) -> Expression:
-        return self._new(self.data.drop(SOLUTION_KEY))
+        return self._new(self.data.drop(SOLUTION_KEY, strict=False))
 
     def _new(self, data: pl.DataFrame):
         e = Expression(data.with_columns(pl.lit(1.0).alias(COEF_KEY)))
@@ -1323,5 +1341,5 @@ class Variable(ModelElementWithId, SupportsMath, SupportPolarsMethodMixin):
         data = expr.data.rename({dim: "__prev"})
         data = data.join(
             wrapped, left_on="__prev", right_on="__next", how="inner"
-        ).drop(["__prev", "__next"])
+        ).drop(["__prev", "__next"], strict=False)
         return expr._new(data)

pyoframe/io.py

@@ -11,8 +11,8 @@ from tqdm import tqdm
 from pyoframe.constants import CONST_TERM, VAR_KEY, ObjSense
 from pyoframe.core import Constraint, Variable
 from pyoframe.io_mappers import (
-    Base62ConstMapper,
-    Base62VarMapper,
+    Base36ConstMapper,
+    Base36VarMapper,
     IOMappers,
     Mapper,
     NamedMapper,
@@ -131,7 +131,7 @@ def get_var_map(m: "Model", use_var_names):
             return m.var_map
         var_map = NamedVariableMapper(Variable)
     else:
-        var_map = Base62VarMapper(Variable)
+        var_map = Base36VarMapper(Variable)
 
     for v in m.variables:
         var_map.add(v)
@@ -139,10 +139,20 @@ def get_var_map(m: "Model", use_var_names):
 
 
 def to_file(
-    m: "Model", file_path: Optional[Union[str, Path]], use_var_names=False
+    m: "Model", file_path: Optional[Union[str, Path]] = None, use_var_names=False
 ) -> Path:
     """
     Write out a model to a lp file.
+
+    Args:
+        m: The model to write out.
+        file_path: The path to write the model to. If None, a temporary file is created. The caller is responsible for
+            deleting the file after use.
+        use_var_names: If True, variable names are used in the lp file. Otherwise, variable
+            indices are used.
+
+    Returns:
+        The path to the lp file.
     """
     if file_path is None:
         with NamedTemporaryFile(
@@ -157,7 +167,7 @@ def to_file(
         file_path.unlink()
 
     const_map = (
-        NamedMapper(Constraint) if use_var_names else Base62ConstMapper(Constraint)
+        NamedMapper(Constraint) if use_var_names else Base36ConstMapper(Constraint)
     )
     for c in m.constraints:
         const_map.add(c)

pyoframe/io_mappers.py

@@ -16,7 +16,7 @@ from pyoframe.constants import CONST_TERM
 if TYPE_CHECKING:  # pragma: no cover
     from pyoframe.model import Variable
     from pyoframe.core import Constraint
-    from pyoframe.util import CountableModelElement
+    from pyoframe.model_element import ModelElementWithId
 
 
 @dataclass
@@ -29,7 +29,7 @@ class Mapper(ABC):
 
     NAME_COL = "__name"
 
-    def __init__(self, cls: Type["CountableModelElement"]) -> None:
+    def __init__(self, cls: Type["ModelElementWithId"]) -> None:
         self._ID_COL = cls.get_id_column_name()
         self.mapping_registry = pl.DataFrame(
             {self._ID_COL: [], Mapper.NAME_COL: []},
@@ -43,7 +43,7 @@ class Mapper(ABC):
         self.mapping_registry = pl.concat([self.mapping_registry, df])
 
     @abstractmethod
-    def _element_to_map(self, element: "CountableModelElement") -> pl.DataFrame: ...
+    def _element_to_map(self, element: "ModelElementWithId") -> pl.DataFrame: ...
 
     def apply(
         self,
@@ -107,13 +107,14 @@ class NamedVariableMapper(NamedMapper):
         )
 
 
-class Base62Mapper(Mapper, ABC):
-    # Mapping between a base 62 character and its integer value
+class Base36Mapper(Mapper, ABC):
+    # Mapping between a base 36 character and its integer value
+    # Note: we must use only lowercase since Gurobi auto-converts variables that aren't in constraints to lowercase (kind of annoying)
     _CHAR_TABLE = pl.DataFrame(
-        {"char": list(string.digits + string.ascii_letters)},
+        {"char": list(string.digits + string.ascii_lowercase)},
     ).with_columns(pl.int_range(pl.len()).cast(pl.UInt32).alias("code"))
 
-    _BASE = _CHAR_TABLE.height  # _BASE = 62
+    _BASE = _CHAR_TABLE.height  # _BASE = 36
     _ZERO = _CHAR_TABLE.filter(pl.col("code") == 0).select("char").item()  # _ZERO = "0"
 
     @property
@@ -131,7 +132,7 @@ class Base62Mapper(Mapper, ABC):
         query = pl.concat_str(
             pl.lit(self._prefix),
             pl.col(self._ID_COL).map_batches(
-                Base62Mapper._to_base62,
+                Base36Mapper._to_base36,
                 return_dtype=pl.String,
                 is_elementwise=True,
             ),
@@ -143,24 +144,24 @@ class Base62Mapper(Mapper, ABC):
         return df.with_columns(query.alias(to_col))
 
     @classmethod
-    def _to_base62(cls, int_col: pl.Series) -> pl.Series:
-        """Returns a series of dtype str with a base 62 representation of the integers in int_col.
-        The letters 0-9a-zA-Z are used as symbols for the representation.
+    def _to_base36(cls, int_col: pl.Series) -> pl.Series:
+        """Returns a series of dtype str with a base 36 representation of the integers in int_col.
+        The letters 0-9A-Z are used as symbols for the representation.
 
         Examples:
 
             >>> import polars as pl
             >>> s = pl.Series([0,10,20,60,53,66], dtype=pl.UInt32)
-            >>> Base62Mapper._to_base62(s).to_list()
-            ['0', 'a', 'k', 'Y', 'R', '14']
+            >>> Base36Mapper._to_base36(s).to_list()
+            ['0', 'a', 'k', '1o', '1h', '1u']
 
             >>> s = pl.Series([0], dtype=pl.UInt32)
-            >>> Base62Mapper._to_base62(s).to_list()
+            >>> Base36Mapper._to_base36(s).to_list()
             ['0']
         """
         assert isinstance(
             int_col.dtype, pl.UInt32
-        ), "_to_base62() only works for UInt32 id columns"
+        ), "_to_base36() only works for UInt32 id columns"
 
         largest_id = int_col.max()
         if largest_id == 0:
@@ -193,7 +194,7 @@ class Base62Mapper(Mapper, ABC):
         return self.apply(element.ids.select(self._ID_COL), to_col=Mapper.NAME_COL)
 
 
-class Base62VarMapper(Base62Mapper):
+class Base36VarMapper(Base36Mapper):
     """
     Examples:
         >>> import polars as pl
@@ -203,10 +204,10 @@ class Base62VarMapper(Base62Mapper):
         >>> m.x = Variable(pl.DataFrame({"t": range(1,63)}))
         >>> (m.x.filter(t=11)+1).to_str()
         '[11]: 1  + x[11]'
-        >>> (m.x.filter(t=11)+1).to_str(var_map=Base62VarMapper(Variable))
+        >>> (m.x.filter(t=11)+1).to_str(var_map=Base36VarMapper(Variable))
         '[11]: 1  + xb'
 
-        >>> Base62VarMapper(Variable).apply(pl.DataFrame({VAR_KEY: []}))
+        >>> Base36VarMapper(Variable).apply(pl.DataFrame({VAR_KEY: []}))
         shape: (0, 1)
         ┌───────────────┐
         │ __variable_id │
@@ -230,7 +231,7 @@ class Base62VarMapper(Base62Mapper):
         return "x"
 
 
-class Base62ConstMapper(Base62Mapper):
+class Base36ConstMapper(Base36Mapper):
 
     @property
     def _prefix(self) -> "str":

pyoframe/model.py

@@ -37,6 +37,7 @@ class Model(AttrContainerMixin):
         "result",
         "attr",
         "sense",
+        "objective",
     ]
 
     def __init__(self, min_or_max: Union[ObjSense, ObjSenseValue], name=None, **kwargs):
@@ -75,6 +76,12 @@ class Model(AttrContainerMixin):
     def objective(self):
         return self._objective
 
+    @objective.setter
+    def objective(self, value):
+        value = Objective(value)
+        self._objective = value
+        value.on_add_to_model(self, "objective")
+
     def __setattr__(self, __name: str, __value: Any) -> None:
         if __name not in Model._reserved_attributes and not isinstance(
             __value, (ModelElement, pl.DataFrame, pd.DataFrame)
@@ -87,9 +94,6 @@ class Model(AttrContainerMixin):
             isinstance(__value, ModelElement)
             and __name not in Model._reserved_attributes
         ):
-            if __name == "objective":
-                __value = Objective(__value)
-
             if isinstance(__value, ModelElementWithId):
                 assert not hasattr(
                     self, __name
@@ -103,9 +107,6 @@ class Model(AttrContainerMixin):
                     self.var_map.add(__value)
             elif isinstance(__value, Constraint):
                 self._constraints.append(__value)
-            elif isinstance(__value, Objective):
-                self._objective = __value
-                return
         return super().__setattr__(__name, __value)
 
     def __repr__(self) -> str:

pyoframe/model_element.py

@@ -109,7 +109,7 @@ def _support_polars_method(method_name: str):
     Wrapper to add a method to ModelElement that simply calls the underlying Polars method on the data attribute.
     """
 
-    def method(self: "SupportPolarsMethodMixin", *args, **kwargs):
+    def method(self: "SupportPolarsMethodMixin", *args, **kwargs) -> Any:
         result_from_polars = getattr(self.data, method_name)(*args, **kwargs)
         if isinstance(result_from_polars, pl.DataFrame):
             return self._new(result_from_polars)
@@ -119,7 +119,7 @@ def _support_polars_method(method_name: str):
     return method
 
 
-class SupportPolarsMethodMixin:
+class SupportPolarsMethodMixin(ABC):
     rename = _support_polars_method("rename")
     with_columns = _support_polars_method("with_columns")
     filter = _support_polars_method("filter")
@@ -131,6 +131,10 @@ class SupportPolarsMethodMixin:
         Used to create a new instance of the same class with the given data (for e.g. on .rename(), .with_columns(), etc.).
         """
 
+    @property
+    @abstractmethod
+    def data(self): ...
+
 
 class ModelElementWithId(ModelElement, AttrContainerMixin):
     """

pyoframe/solvers.py

@@ -5,7 +5,7 @@ Code to interface with various solvers
 from abc import abstractmethod, ABC
 from functools import lru_cache
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Type, Union, TYPE_CHECKING
+from typing import Any, Dict, Optional, Type, Union, TYPE_CHECKING
 
 import polars as pl
 
@@ -50,7 +50,6 @@ def solve(
     solver=None,
     directory: Optional[Union[Path, str]] = None,
     use_var_names=False,
-    env=None,
     log_fn=None,
     warmstart_fn=None,
     basis_fn=None,
@@ -68,8 +67,13 @@ def solve(
         raise ValueError(f"Solver {solver} not recognized or supported.")
 
     solver_cls = solver_registry[solver]
-    m.solver = solver_cls(m, log_to_console)
-    m.solver_model = m.solver.create_solver_model(directory, use_var_names, env)
+    m.solver = solver_cls(
+        m,
+        log_to_console,
+        params={param: value for param, value in m.params},
+        directory=directory,
+    )
+    m.solver_model = m.solver.create_solver_model(use_var_names)
     m.solver.solver_model = m.solver_model
 
     for attr_container in [m.variables, m.constraints, [m]]:
@@ -77,9 +81,6 @@ def solve(
             for param_name, param_value in container.attr:
                 m.solver.set_attr(container, param_name, param_value)
 
-    for param, value in m.params:
-        m.solver.set_param(param, value)
-
     result = m.solver.solve(log_fn, warmstart_fn, basis_fn, solution_file)
     result = m.solver.process_result(result)
     m.result = result
@@ -99,20 +100,19 @@ def solve(
 
 
 class Solver(ABC):
-    def __init__(self, model, log_to_console):
+    def __init__(self, model: "Model", log_to_console, params, directory):
         self._model = model
         self.solver_model: Optional[Any] = None
-        self.log_to_console = log_to_console
+        self.log_to_console: bool = log_to_console
+        self.params = params
+        self.directory = directory
 
     @abstractmethod
-    def create_solver_model(self) -> Any: ...
+    def create_solver_model(self, use_var_names) -> Any: ...
 
     @abstractmethod
     def set_attr(self, element, param_name, param_value): ...
 
-    @abstractmethod
-    def set_param(self, param_name, param_value): ...
-
     @abstractmethod
     def solve(self, log_fn, warmstart_fn, basis_fn, solution_file) -> Result: ...
 
@@ -135,12 +135,25 @@ class Solver(ABC):
     @abstractmethod
     def _get_all_slack(self): ...
 
+    def dispose(self):
+        """
+        Clean up any resources that wouldn't be cleaned up by the garbage collector.
+
+        For now, this is only used by the Gurobi solver to call .dispose() on the solver model and Gurobi environment
+        which helps close a connection to the Gurobi Computer Server. Note that this effectively disables commands that
+        need access to the solver model (like .slack and .RC)
+        """
+
 
 class FileBasedSolver(Solver):
-    def create_solver_model(
-        self, directory: Optional[Union[Path, str]], use_var_names, env
-    ) -> Any:
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.problem_file: Optional[Path] = None
+        self.keep_files = self.directory is not None
+
+    def create_solver_model(self, use_var_names) -> Any:
         problem_file = None
+        directory = self.directory
         if directory is not None:
             if isinstance(directory, str):
                 directory = Path(directory)
@@ -150,12 +163,14 @@ class FileBasedSolver(Solver):
                 self._model.name if self._model.name is not None else "pyoframe-problem"
             )
             problem_file = directory / f"{filename}.lp"
-        problem_file = self._model.to_file(problem_file, use_var_names=use_var_names)
+        self.problem_file = self._model.to_file(
+            problem_file, use_var_names=use_var_names
+        )
         assert self._model.io_mappers is not None
-        return self.create_solver_model_from_lp(problem_file, env)
+        return self.create_solver_model_from_lp()
 
     @abstractmethod
-    def create_solver_model_from_lp(self, problem_file: Path, env) -> Any: ...
+    def create_solver_model_from_lp(self) -> Any: ...
 
     def set_attr(self, element, param_name, param_value):
         if isinstance(param_value, pl.DataFrame):
@@ -216,30 +231,30 @@ class GurobiSolver(FileBasedSolver):
         17: "internal_solver_error",
     }
 
-    def create_solver_model_from_lp(self, problem_fn, env) -> Result:
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        if not self.log_to_console:
+            self.params["LogToConsole"] = 0
+        self.env = None
+
+    def create_solver_model_from_lp(self) -> Any:
         """
         Solve a linear problem using the gurobi solver.
 
         This function communicates with gurobi using the gurubipy package.
         """
+        assert self.problem_file is not None
+        self.env = gurobipy.Env(params=self.params)
 
-        if env is None:
-            if self.log_to_console:
-                env = gurobipy.Env()
-            else:
-                # See https://support.gurobi.com/hc/en-us/articles/360044784552-How-do-I-suppress-all-console-output-from-Gurobi
-                env = gurobipy.Env(empty=True)
-                env.setParam("LogToConsole", 0)
-                env.start()
+        m = gurobipy.read(_path_to_str(self.problem_file), env=self.env)
+        if not self.keep_files:
+            self.problem_file.unlink()
 
-        m = gurobipy.read(_path_to_str(problem_fn), env=env)
         return m
 
-    def set_param(self, param_name, param_value):
-        self.solver_model.setParam(param_name, param_value)
-
     @lru_cache
     def _get_var_mapping(self):
+        assert self.solver_model is not None
         vars = self.solver_model.getVars()
         return vars, pl.DataFrame(
             {VAR_KEY: self.solver_model.getAttr("VarName", vars)}
@@ -247,12 +262,14 @@ class GurobiSolver(FileBasedSolver):
 
     @lru_cache
     def _get_constraint_mapping(self):
+        assert self.solver_model is not None
         constraints = self.solver_model.getConstrs()
         return constraints, pl.DataFrame(
             {CONSTRAINT_KEY: self.solver_model.getAttr("ConstrName", constraints)}
         ).with_columns(i=pl.int_range(pl.len()))
 
     def set_attr_unmapped(self, element, param_name, param_value):
+        assert self.solver_model is not None
         if isinstance(element, pf.Model):
             self.solver_model.setAttr(param_name, param_value)
         elif isinstance(element, pf.Variable):
@@ -277,6 +294,7 @@ class GurobiSolver(FileBasedSolver):
             raise ValueError(f"Element type {type(element)} not recognized.")
 
     def solve(self, log_fn, warmstart_fn, basis_fn, solution_file) -> Result:
+        assert self.solver_model is not None
         m = self.solver_model
         if log_fn is not None:
             m.setParam("logfile", _path_to_str(log_fn))
@@ -295,7 +313,7 @@ class GurobiSolver(FileBasedSolver):
         termination_condition = GurobiSolver.CONDITION_MAP.get(condition, condition)
         status = Status.from_termination_condition(termination_condition)
 
-        if status.is_ok:
+        if status.is_ok and (termination_condition == "optimal"):
             if solution_file:
                 m.write(_path_to_str(solution_file))
 
@@ -345,6 +363,12 @@ class GurobiSolver(FileBasedSolver):
             }
         )
 
+    def dispose(self):
+        if self.solver_model is not None:
+            self.solver_model.dispose()
+        if self.env is not None:
+            self.env.dispose()
+
 
 def _path_to_str(path: Union[Path, str]) -> str:
     """

{pyoframe-0.0.5.dist-info → pyoframe-0.0.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyoframe
-Version: 0.0.5
+Version: 0.0.7
 Summary: Blazing fast linear program interface
 Author-email: Bravos Power <dev@bravospower.com>
 Project-URL: Homepage, https://bravos-power.github.io/pyoframe/

pyoframe-0.0.7.dist-info/RECORD

@@ -0,0 +1,18 @@
+pyoframe/__init__.py,sha256=D7HHQPy2Me-LLyfPCcSE74dn83PeMK3aOby7i7oiLTs,507
+pyoframe/_arithmetic.py,sha256=riyN2JC-BnOgTIxGfXKIS-X_p7zm8JaKrLk_KDwKAAw,9046
+pyoframe/constants.py,sha256=olao24mkzQfwTlc5o4rQ-AOOTytmtVqNCFwJIc8zbds,7169
+pyoframe/core.py,sha256=TwpWPYl1K5qDSFAX9yfabFKpahxgqoa2eL0zmkP91dI,51247
+pyoframe/io.py,sha256=7bd_oKD8EZsuM0ONUAA9BDFSFvUoXLWGXDhnUqMde8o,5235
+pyoframe/io_mappers.py,sha256=Op5451Yo4gNa-2BiPPCAjPYdFLo8jIeKHCYXUcGPRug,7385
+pyoframe/model.py,sha256=xod3hSf__WWDy0V9pao9wPlQTc7-7x56FJoKKidsMbw,3768
+pyoframe/model_element.py,sha256=H2gZxksb3UQ25vIdNlb07bCx3ZcWh7YD6-ViPVJV-JI,7691
+pyoframe/monkey_patch.py,sha256=S_DU7cieU5C3t3kAyKQrGyLTwno0WANpDBV3xn7AyG8,2068
+pyoframe/objective.py,sha256=JzuyMAQZ2OxEoAaK-splWwZei2hHPbCLdG-X2-yRkD0,1338
+pyoframe/solvers.py,sha256=yf-hzUHDvKgmIHk2FobmygzE9-LnOzTBL5ps-nqGo8I,11875
+pyoframe/user_defined.py,sha256=UWZSTpFj0a8n1_RHwC8Ubwqr4FO-gRPBqqfNUut1IZg,1717
+pyoframe/util.py,sha256=KJubFV66E7WPI5UhcuUNsVwCm7WOcQBiLN1af1MAAgA,9647
+pyoframe-0.0.7.dist-info/LICENSE,sha256=L1pXz6p_1OW5XGWb2UCR6PNu6k3JAT0XWhi8jV0cuRg,1137
+pyoframe-0.0.7.dist-info/METADATA,sha256=zKjbfnByq8u6GRauys4BbRuWjL6SGiCmd9SBhwTDFCE,3445
+pyoframe-0.0.7.dist-info/WHEEL,sha256=y4mX-SOX4fYIkonsAGA5N0Oy-8_gI4FXw5HNI1xqvWg,91
+pyoframe-0.0.7.dist-info/top_level.txt,sha256=10z3OOJSVLriQ0IrFLMH8CH9zByugPWolqhlHlkNjV4,9
+pyoframe-0.0.7.dist-info/RECORD,,

{pyoframe-0.0.5.dist-info → pyoframe-0.0.7.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.43.0)
+Generator: setuptools (70.2.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

pyoframe-0.0.5.dist-info/RECORD

@@ -1,18 +0,0 @@
-pyoframe/__init__.py,sha256=D7HHQPy2Me-LLyfPCcSE74dn83PeMK3aOby7i7oiLTs,507
-pyoframe/_arithmetic.py,sha256=MIUSuvhGjBixzQCX-B7D8pMXwDE-d0Q4_f9vPNHAzys,9030
-pyoframe/constants.py,sha256=KZJaHRlvGvhIoZbjqNEc5UdXmjK8RgsXG-nVFAJ7sws,7121
-pyoframe/core.py,sha256=uBRfy4gpG9B08agjCo4nX6gCEUw1rz33X68Q6UQy-QM,50583
-pyoframe/io.py,sha256=2YNo6SJkbTwAIseCZU10wCrbXNexXYGU6sq6ET895Ds,4853
-pyoframe/io_mappers.py,sha256=xWvWarwzudMvJ1L70l-xSQgFCwHonmC0th5AqilTpIE,7249
-pyoframe/model.py,sha256=5ATWB-04UurPHiEuiSjSxB7CVWsdvj4el76dcQmHAyo,3776
-pyoframe/model_element.py,sha256=N9P56YbD_iscrgRk4yT-oW7pSuwMFDdjxxKVPvMwJ8U,7620
-pyoframe/monkey_patch.py,sha256=S_DU7cieU5C3t3kAyKQrGyLTwno0WANpDBV3xn7AyG8,2068
-pyoframe/objective.py,sha256=JzuyMAQZ2OxEoAaK-splWwZei2hHPbCLdG-X2-yRkD0,1338
-pyoframe/solvers.py,sha256=b9nSw5k-ko4eiA5Ad3z4vlcgp-pTyNeIWHQ7N4zV_AE,10994
-pyoframe/user_defined.py,sha256=UWZSTpFj0a8n1_RHwC8Ubwqr4FO-gRPBqqfNUut1IZg,1717
-pyoframe/util.py,sha256=KJubFV66E7WPI5UhcuUNsVwCm7WOcQBiLN1af1MAAgA,9647
-pyoframe-0.0.5.dist-info/LICENSE,sha256=L1pXz6p_1OW5XGWb2UCR6PNu6k3JAT0XWhi8jV0cuRg,1137
-pyoframe-0.0.5.dist-info/METADATA,sha256=FV-aSYBS5nMnegxZgtdzEDRFZZth4DJDdo_KYfjwbOQ,3445
-pyoframe-0.0.5.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-pyoframe-0.0.5.dist-info/top_level.txt,sha256=10z3OOJSVLriQ0IrFLMH8CH9zByugPWolqhlHlkNjV4,9
-pyoframe-0.0.5.dist-info/RECORD,,