pyomo-pounce 0.2.0__tar.gz

pyomo_pounce-0.2.0/PKG-INFO

@@ -0,0 +1,94 @@
+Metadata-Version: 2.4
+Name: pyomo-pounce
+Version: 0.2.0
+Summary: Pyomo solver plugin for the POUNCE interior-point NLP solver
+Author-email: John Kitchin <jkitchin@andrew.cmu.edu>
+License: EPL-2.0
+Project-URL: Homepage, https://github.com/jkitchin/pounce
+Project-URL: Repository, https://github.com/jkitchin/pounce
+Project-URL: Issues, https://github.com/jkitchin/pounce/issues
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: Eclipse Public License 2.0 (EPL-2.0)
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: pyomo>=6.0
+Requires-Dist: pounce-solver>=0.1
+
+# pyomo-pounce
+
+Pyomo solver plugin for [POUNCE](https://github.com/jkitchin/pounce), a
+pure-Rust interior-point NLP solver (a Rust port of IPOPT).
+
+POUNCE speaks the AMPL NL/SOL protocol, so Pyomo drives it through the
+AMPL Solver Library interface — exactly how Pyomo integrates with IPOPT.
+
+## Installation
+
+```bash
+pip install pyomo-pounce
+```
+
+That single command pulls in the `pounce-solver` dependency, which
+ships a per-platform wheel bundling the `pounce` executable. After
+install, `pounce` is on your `PATH` and Pyomo finds it automatically.
+
+## Usage
+
+```python
+import pyomo_pounce  # registers the solver
+from pyomo.environ import *
+
+model = ConcreteModel()
+model.x = Var(initialize=0.5)
+model.obj = Objective(expr=(model.x - 2)**2)
+
+solver = SolverFactory('pounce')
+result = solver.solve(model, tee=True)
+print(f"x* = {value(model.x)}")  # 2.0
+```
+
+## Solver Options
+
+Pass options the same way as IPOPT:
+
+```python
+solver = SolverFactory('pounce')
+solver.options['max_iter'] = 1000
+solver.options['tol'] = 1e-10
+solver.options['print_level'] = 5
+```
+
+Options are forwarded to POUNCE's `OptionsList` (ipopt.opt-compatible
+keys).
+
+## Local development / unsupported platforms
+
+If `pounce-solver` does not ship a wheel for your platform, the pip
+install fails on the dependency. Two workarounds:
+
+1. **Build POUNCE from source and put it on `PATH`** — the plugin
+   resolves `pounce` via `shutil.which`, so any binary on `PATH`
+   works:
+
+   ```bash
+   # in the pounce repo
+   cargo build --release --bin pounce
+   export PATH="$PWD/target/release:$PATH"
+   pip install --no-deps pyomo-pounce pyomo
+   ```
+
+2. **Install `pounce-solver` from source** via maturin:
+
+   ```bash
+   cd pounce/python && maturin develop --release
+   # then `cargo install --path ../crates/pounce-cli` to get the CLI
+   # since maturin develop does not bundle the binary.
+   pip install pyomo-pounce
+   ```
+
+## License
+
+EPL-2.0, same as POUNCE.

pyomo_pounce-0.2.0/README.md

@@ -0,0 +1,75 @@
+# pyomo-pounce
+
+Pyomo solver plugin for [POUNCE](https://github.com/jkitchin/pounce), a
+pure-Rust interior-point NLP solver (a Rust port of IPOPT).
+
+POUNCE speaks the AMPL NL/SOL protocol, so Pyomo drives it through the
+AMPL Solver Library interface — exactly how Pyomo integrates with IPOPT.
+
+## Installation
+
+```bash
+pip install pyomo-pounce
+```
+
+That single command pulls in the `pounce-solver` dependency, which
+ships a per-platform wheel bundling the `pounce` executable. After
+install, `pounce` is on your `PATH` and Pyomo finds it automatically.
+
+## Usage
+
+```python
+import pyomo_pounce  # registers the solver
+from pyomo.environ import *
+
+model = ConcreteModel()
+model.x = Var(initialize=0.5)
+model.obj = Objective(expr=(model.x - 2)**2)
+
+solver = SolverFactory('pounce')
+result = solver.solve(model, tee=True)
+print(f"x* = {value(model.x)}")  # 2.0
+```
+
+## Solver Options
+
+Pass options the same way as IPOPT:
+
+```python
+solver = SolverFactory('pounce')
+solver.options['max_iter'] = 1000
+solver.options['tol'] = 1e-10
+solver.options['print_level'] = 5
+```
+
+Options are forwarded to POUNCE's `OptionsList` (ipopt.opt-compatible
+keys).
+
+## Local development / unsupported platforms
+
+If `pounce-solver` does not ship a wheel for your platform, the pip
+install fails on the dependency. Two workarounds:
+
+1. **Build POUNCE from source and put it on `PATH`** — the plugin
+   resolves `pounce` via `shutil.which`, so any binary on `PATH`
+   works:
+
+   ```bash
+   # in the pounce repo
+   cargo build --release --bin pounce
+   export PATH="$PWD/target/release:$PATH"
+   pip install --no-deps pyomo-pounce pyomo
+   ```
+
+2. **Install `pounce-solver` from source** via maturin:
+
+   ```bash
+   cd pounce/python && maturin develop --release
+   # then `cargo install --path ../crates/pounce-cli` to get the CLI
+   # since maturin develop does not bundle the binary.
+   pip install pyomo-pounce
+   ```
+
+## License
+
+EPL-2.0, same as POUNCE.

pyomo_pounce-0.2.0/pyomo_pounce/__init__.py

@@ -0,0 +1,10 @@
+"""Pyomo solver plugin for the POUNCE interior-point NLP solver.
+
+Usage:
+    import pyomo_pounce  # registers 'pounce' with SolverFactory
+    from pyomo.environ import *
+    solver = SolverFactory('pounce')
+"""
+from pyomo_pounce.pounce_solver import POUNCE
+
+__all__ = ["POUNCE"]

pyomo_pounce-0.2.0/pyomo_pounce/pounce_solver.py

@@ -0,0 +1,36 @@
+"""POUNCE solver plugin for Pyomo.
+
+Registers 'pounce' with Pyomo's SolverFactory. POUNCE speaks the AMPL
+NL/SOL protocol, so Pyomo drives it through the AMPL Solver Library
+interface exactly as it drives IPOPT.
+
+The `pounce` binary is provided by the `pounce-solver` dependency,
+which ships a per-platform wheel that drops the executable into the
+active environment under `<venv>/bin/pounce`. Falls back to any
+`pounce` already on PATH for system installs or local dev builds
+(`cargo install --path crates/pounce-cli`).
+
+Usage:
+    import pyomo_pounce
+    from pyomo.environ import *
+    solver = SolverFactory('pounce')
+    result = solver.solve(model)
+"""
+import shutil
+
+from pyomo.opt import SolverFactory
+from pyomo.solvers.plugins.solvers.ASL import ASL
+
+
+@SolverFactory.register("pounce", doc="The POUNCE interior-point NLP solver")
+class POUNCE(ASL):
+    """Pyomo solver interface for POUNCE via the AMPL Solver Library protocol."""
+
+    def __init__(self, **kwds):
+        kwds["type"] = "pounce"
+        super().__init__(**kwds)
+        self._metasolver = False
+        self.options.solver = "pounce"
+
+    def _default_executable(self):
+        return shutil.which("pounce")

pyomo_pounce-0.2.0/pyomo_pounce.egg-info/PKG-INFO

@@ -0,0 +1,94 @@
+Metadata-Version: 2.4
+Name: pyomo-pounce
+Version: 0.2.0
+Summary: Pyomo solver plugin for the POUNCE interior-point NLP solver
+Author-email: John Kitchin <jkitchin@andrew.cmu.edu>
+License: EPL-2.0
+Project-URL: Homepage, https://github.com/jkitchin/pounce
+Project-URL: Repository, https://github.com/jkitchin/pounce
+Project-URL: Issues, https://github.com/jkitchin/pounce/issues
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: Eclipse Public License 2.0 (EPL-2.0)
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: pyomo>=6.0
+Requires-Dist: pounce-solver>=0.1
+
+# pyomo-pounce
+
+Pyomo solver plugin for [POUNCE](https://github.com/jkitchin/pounce), a
+pure-Rust interior-point NLP solver (a Rust port of IPOPT).
+
+POUNCE speaks the AMPL NL/SOL protocol, so Pyomo drives it through the
+AMPL Solver Library interface — exactly how Pyomo integrates with IPOPT.
+
+## Installation
+
+```bash
+pip install pyomo-pounce
+```
+
+That single command pulls in the `pounce-solver` dependency, which
+ships a per-platform wheel bundling the `pounce` executable. After
+install, `pounce` is on your `PATH` and Pyomo finds it automatically.
+
+## Usage
+
+```python
+import pyomo_pounce  # registers the solver
+from pyomo.environ import *
+
+model = ConcreteModel()
+model.x = Var(initialize=0.5)
+model.obj = Objective(expr=(model.x - 2)**2)
+
+solver = SolverFactory('pounce')
+result = solver.solve(model, tee=True)
+print(f"x* = {value(model.x)}")  # 2.0
+```
+
+## Solver Options
+
+Pass options the same way as IPOPT:
+
+```python
+solver = SolverFactory('pounce')
+solver.options['max_iter'] = 1000
+solver.options['tol'] = 1e-10
+solver.options['print_level'] = 5
+```
+
+Options are forwarded to POUNCE's `OptionsList` (ipopt.opt-compatible
+keys).
+
+## Local development / unsupported platforms
+
+If `pounce-solver` does not ship a wheel for your platform, the pip
+install fails on the dependency. Two workarounds:
+
+1. **Build POUNCE from source and put it on `PATH`** — the plugin
+   resolves `pounce` via `shutil.which`, so any binary on `PATH`
+   works:
+
+   ```bash
+   # in the pounce repo
+   cargo build --release --bin pounce
+   export PATH="$PWD/target/release:$PATH"
+   pip install --no-deps pyomo-pounce pyomo
+   ```
+
+2. **Install `pounce-solver` from source** via maturin:
+
+   ```bash
+   cd pounce/python && maturin develop --release
+   # then `cargo install --path ../crates/pounce-cli` to get the CLI
+   # since maturin develop does not bundle the binary.
+   pip install pyomo-pounce
+   ```
+
+## License
+
+EPL-2.0, same as POUNCE.

pyomo_pounce-0.2.0/pyomo_pounce.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+README.md
+pyproject.toml
+pyomo_pounce/__init__.py
+pyomo_pounce/pounce_solver.py
+pyomo_pounce.egg-info/PKG-INFO
+pyomo_pounce.egg-info/SOURCES.txt
+pyomo_pounce.egg-info/dependency_links.txt
+pyomo_pounce.egg-info/entry_points.txt
+pyomo_pounce.egg-info/requires.txt
+pyomo_pounce.egg-info/top_level.txt
+tests/test_pounce.py

pyomo_pounce-0.2.0/pyomo_pounce.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pyomo_pounce-0.2.0/pyomo_pounce.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[pyomo.solvers]
+pounce = pyomo_pounce.pounce_solver

pyomo_pounce-0.2.0/pyomo_pounce.egg-info/requires.txt

@@ -0,0 +1,2 @@
+pyomo>=6.0
+pounce-solver>=0.1

pyomo_pounce-0.2.0/pyomo_pounce.egg-info/top_level.txt

@@ -0,0 +1 @@
+pyomo_pounce

pyomo_pounce-0.2.0/pyproject.toml

@@ -0,0 +1,39 @@
+[build-system]
+requires = ["setuptools>=64"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pyomo-pounce"
+version = "0.2.0"
+description = "Pyomo solver plugin for the POUNCE interior-point NLP solver"
+readme = "README.md"
+requires-python = ">=3.9"
+license = {text = "EPL-2.0"}
+authors = [{name = "John Kitchin", email = "jkitchin@andrew.cmu.edu"}]
+# Pyomo gives us the SolverFactory machinery; pounce-solver supplies
+# the actual `pounce` executable on PATH (it ships the Rust CLI inside
+# its wheel). Pinning >=0.1 keeps us forward-compatible across POUNCE
+# point releases; tighten if we ever need to coordinate Pyomo/POUNCE
+# API changes.
+dependencies = [
+    "pyomo>=6.0",
+    "pounce-solver>=0.1",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: Eclipse Public License 2.0 (EPL-2.0)",
+    "Programming Language :: Python :: 3",
+    "Topic :: Scientific/Engineering :: Mathematics",
+]
+
+[project.urls]
+Homepage = "https://github.com/jkitchin/pounce"
+Repository = "https://github.com/jkitchin/pounce"
+Issues = "https://github.com/jkitchin/pounce/issues"
+
+[project.entry-points."pyomo.solvers"]
+pounce = "pyomo_pounce.pounce_solver"
+
+[tool.setuptools.packages.find]
+include = ["pyomo_pounce*"]

pyomo_pounce-0.2.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pyomo_pounce-0.2.0/tests/test_pounce.py

@@ -0,0 +1,68 @@
+"""Smoke tests for the pyomo-pounce solver plugin.
+
+Run with `pytest`. The `pounce` binary must be on PATH (or bundled).
+"""
+import pytest
+
+import pyomo_pounce  # noqa: F401  (registers 'pounce' with SolverFactory)
+from pyomo.environ import (
+    ConcreteModel,
+    Constraint,
+    NonNegativeReals,
+    Objective,
+    SolverFactory,
+    Var,
+    value,
+)
+
+
+@pytest.fixture(scope="module")
+def solver():
+    s = SolverFactory("pounce")
+    if not s.available(exception_flag=False):
+        pytest.skip("pounce binary not found on PATH")
+    return s
+
+
+def test_registered():
+    assert SolverFactory("pounce") is not None
+
+
+def test_unconstrained(solver):
+    """min (x - 2)^2  ->  x* = 2."""
+    m = ConcreteModel()
+    m.x = Var(initialize=0.5)
+    m.obj = Objective(expr=(m.x - 2) ** 2)
+
+    solver.solve(m)
+
+    assert value(m.x) == pytest.approx(2.0, abs=1e-6)
+
+
+def test_constrained(solver):
+    """min (x-2)^2 + (y-3)^2  s.t. x + y <= 4  ->  (1.5, 2.5)."""
+    m = ConcreteModel()
+    m.x = Var(domain=NonNegativeReals, initialize=1.0)
+    m.y = Var(domain=NonNegativeReals, initialize=1.0)
+    m.obj = Objective(expr=(m.x - 2) ** 2 + (m.y - 3) ** 2)
+    m.budget = Constraint(expr=m.x + m.y <= 4)
+
+    solver.solve(m)
+
+    assert value(m.x) == pytest.approx(1.5, abs=1e-5)
+    assert value(m.y) == pytest.approx(2.5, abs=1e-5)
+
+
+def test_options_forwarded(solver):
+    """`max_iter` is forwarded; 0 iterations cannot reach optimality."""
+    m = ConcreteModel()
+    m.x = Var(initialize=0.5)
+    m.obj = Objective(expr=(m.x - 2) ** 2)
+
+    solver.options["max_iter"] = 0
+    try:
+        result = solver.solve(m)
+    finally:
+        del solver.options["max_iter"]
+
+    assert str(result.solver.termination_condition) != "optimal"