openscvx 0.4.1.dev161__tar.gz → 0.4.1.dev163__tar.gz

{openscvx-0.4.1.dev161 → openscvx-0.4.1.dev163}/.github/workflows/tests-integration.yml

@@ -40,7 +40,7 @@ jobs:
 
     - name: Run integration tests
       run: |
-        pytest -v -m integration --durations=10
+        pytest -v -m integration --durations=10 -n auto
 
     - name: Upload test results on failure
       if: failure()

{openscvx-0.4.1.dev161 → openscvx-0.4.1.dev163}/.github/workflows/tests-unit.yml

@@ -43,7 +43,7 @@ jobs:
 
     - name: Run unit tests
       run: |
-        pytest -v -m "not integration" --durations=10 --tb=short
+        pytest -v -m "not integration" --durations=10 --tb=short -n auto
 
     - name: Upload test results on failure
       if: failure()

{openscvx-0.4.1.dev161/openscvx.egg-info → openscvx-0.4.1.dev163}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openscvx
-Version: 0.4.1.dev161
+Version: 0.4.1.dev163
 Summary: A general Python-based successive convexification implementation which uses a JAX backend.
 Author-email: Chris Hayner and Griffin Norris <haynec@uw.edu>
 License: Apache Software License
@@ -22,6 +22,7 @@ Requires-Dist: flatbuffers
 Requires-Dist: viser
 Requires-Dist: matplotlib
 Requires-Dist: pyyaml
+Requires-Dist: pydantic>=2.0
 Provides-Extra: gui
 Requires-Dist: pyqtgraph; extra == "gui"
 Requires-Dist: PyQt5; extra == "gui"
@@ -40,6 +41,7 @@ Requires-Dist: pytest; extra == "test"
 Requires-Dist: scipy; extra == "test"
 Requires-Dist: jaxlie; extra == "test"
 Requires-Dist: svgpathtools; extra == "test"
+Requires-Dist: pytest-xdist; extra == "test"
 Dynamic: license-file
 
 <a id="readme-top"></a>

openscvx-0.4.1.dev163/openscvx/__main__.py

@@ -0,0 +1,103 @@
+"""CLI entry point: ``openscvx path/to/problem.yaml``."""
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+
+def _cmd_solve(args):
+    """Solve a trajectory optimization problem from a YAML/JSON file."""
+    path: Path = args.config
+    if not path.exists():
+        print(f"Error: file not found: {path}", file=sys.stderr)
+        sys.exit(1)
+
+    suffix = path.suffix.lower()
+    if suffix in (".yaml", ".yml"):
+        from openscvx.loader import load_yaml
+
+        kwargs = load_yaml(path)
+    elif suffix == ".json":
+        from openscvx.loader import load_json
+
+        kwargs = load_json(path)
+    else:
+        print(
+            f"Error: unsupported file type {suffix!r} (expected .yaml, .yml, or .json)",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+
+    from openscvx.problem import Problem
+
+    settings = kwargs.pop("settings", None)
+    problem = Problem(**kwargs)
+    if settings:
+        problem.settings.apply_dict(settings)
+    problem.initialize()
+    result = problem.solve()
+    result = problem.post_process()
+
+    if args.output:
+        result.save(args.output)
+        print(f"Results saved to {args.output}")
+
+
+def _cmd_schema(args):
+    """Generate the JSON Schema for the YAML/JSON problem format."""
+    from openscvx.loader import ProblemSpec
+
+    schema = json.dumps(ProblemSpec.model_json_schema(), indent=2) + "\n"
+
+    if args.output:
+        args.output.write_text(schema)
+        print(f"Schema written to {args.output}", file=sys.stderr)
+    else:
+        sys.stdout.write(schema)
+
+
+def main():
+    # Backwards compat: bare `openscvx path/to/problem.yaml` (no subcommand).
+    # Detect this before argparse sees the args, and prepend "solve".
+    _SUBCOMMANDS = {"solve", "schema", "-h", "--help"}
+    if len(sys.argv) > 1 and sys.argv[1] not in _SUBCOMMANDS:
+        sys.argv.insert(1, "solve")
+
+    parser = argparse.ArgumentParser(
+        prog="openscvx",
+        description="OpenSCvx trajectory optimization toolkit.",
+    )
+    subparsers = parser.add_subparsers(dest="command")
+
+    # --- solve ---
+    solve_parser = subparsers.add_parser(
+        "solve",
+        help="Solve a trajectory optimization problem from a YAML/JSON config file.",
+    )
+    solve_parser.add_argument(
+        "config", type=Path, help="Path to a YAML or JSON problem definition file"
+    )
+    solve_parser.add_argument("-o", "--output", type=Path, help="Save results to a .npz file")
+    solve_parser.set_defaults(func=_cmd_solve)
+
+    # --- schema ---
+    schema_parser = subparsers.add_parser(
+        "schema",
+        help="Print the JSON Schema for the YAML/JSON problem format.",
+    )
+    schema_parser.add_argument(
+        "-o", "--output", type=Path, help="Write schema to a file instead of stdout"
+    )
+    schema_parser.set_defaults(func=_cmd_schema)
+
+    args = parser.parse_args()
+    if args.command is None:
+        parser.print_help()
+        sys.exit(1)
+
+    args.func(args)
+
+
+if __name__ == "__main__":
+    main()

{openscvx-0.4.1.dev161 → openscvx-0.4.1.dev163}/openscvx/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.4.1.dev161'
-__version_tuple__ = version_tuple = (0, 4, 1, 'dev161')
+__version__ = version = '0.4.1.dev163'
+__version_tuple__ = version_tuple = (0, 4, 1, 'dev163')
 
-__commit_id__ = commit_id = 'g2094cea6c'
+__commit_id__ = commit_id = 'g18f7230f1'

openscvx-0.4.1.dev163/openscvx/algorithms/__init__.py

@@ -0,0 +1,180 @@
+"""Successive convexification algorithms for trajectory optimization.
+
+This module provides implementations of SCvx (Successive Convexification) algorithms
+for solving non-convex trajectory optimization problems through iterative convex
+approximation.
+
+All algorithms inherit from :class:`Algorithm`, enabling pluggable algorithm
+implementations and custom SCvx variants:
+
+```python
+class Algorithm(ABC):
+    @abstractmethod
+    def initialize(self, solver, discretization_solver, jax_constraints,
+                   emitter, params, settings) -> None:
+        '''Store compiled infrastructure and warm-start solvers.'''
+        ...
+
+    @abstractmethod
+    def step(self, state, params, settings) -> bool:
+        '''Execute one iteration using stored infrastructure.'''
+        ...
+```
+
+Immutable components (solver, discretization_solver, jax_constraints, etc.) are stored
+during ``initialize()``. Mutable configuration (params, settings) is passed per-step
+to support runtime parameter updates and tolerance tuning.
+
+:class:`AlgorithmState` holds mutable state during SCP iterations. Algorithms
+that require additional state can subclass it:
+
+```python
+@dataclass
+class MyAlgorithmState(AlgorithmState):
+    my_custom_field: float = 0.0
+```
+
+Note:
+    ``AlgorithmState`` currently combines iteration metrics (costs, weights),
+    trajectory history, and discretization data. A future refactor may separate
+    these concerns into distinct classes for clearer data flow:
+
+    ```python
+    @dataclass
+    class AlgorithmState:
+        # Mutable iteration state
+        k: int
+        J_tr: float
+        J_vb: float
+        J_vc: float
+        lam_prox: float
+        lam_cost: float
+        lam_vc: ...
+        lam_vb_nodal: np.ndarray  # (N, n_nodal)
+        lam_vb_cross: np.ndarray  # (n_cross,)
+
+    @dataclass
+    class TrajectoryHistory:
+        # Accumulated trajectory solutions
+        X: List[np.ndarray]
+        U: List[np.ndarray]
+
+        @property
+        def x(self): return self.X[-1]
+
+        @property
+        def u(self): return self.U[-1]
+
+    @dataclass
+    class DebugHistory:
+        # Optional diagnostic data (discretization matrices, etc.)
+        V_history: List[np.ndarray]
+        VC_history: List[np.ndarray]
+        TR_history: List[np.ndarray]
+    ```
+
+Current Implementations:
+
+- :class:`PenalizedTrustRegion`: Penalized Trust Region (PTR) algorithm
+"""
+
+from typing import Annotated, Any, Dict, List, Optional, Union
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator
+
+from .augmented_lagrangian import AugmentedLagrangian, AugmentedLagrangianSpec
+from .base import Algorithm, AlgorithmState, AutotuningBase, DiscretizationResult
+from .constant_proximal_weight import ConstantProximalWeight, ConstantProximalWeightSpec
+from .optimization_results import OptimizationResults
+from .penalized_trust_region import PenalizedTrustRegion
+from .ramp_proximal_weight import RampProximalWeight, RampProximalWeightSpec
+from .weights import Weights
+
+# ---------------------------------------------------------------------------
+# Autotuner config — discriminated union of each autotuner's Spec
+# ---------------------------------------------------------------------------
+
+AutotunerConfig = Annotated[
+    Union[
+        AugmentedLagrangianSpec,
+        RampProximalWeightSpec,
+        ConstantProximalWeightSpec,
+    ],
+    Field(discriminator="type"),
+]
+
+# ---------------------------------------------------------------------------
+# Algorithm config model
+# ---------------------------------------------------------------------------
+
+
+class PenalizedTrustRegionConfig(BaseModel):
+    """Validates PenalizedTrustRegion configuration from dict input.
+
+    The ``autotuner`` field accepts:
+
+    * ``None`` — defaults to :class:`AugmentedLagrangian`.
+    * A **string** — class name only, default parameters.
+    * A **dict** — class name via ``"type"`` key plus overrides.
+    * An **instance** — already-constructed autotuner (pass-through).
+    """
+
+    autotuner: Optional[Union[AutotunerConfig, AutotuningBase]] = None
+
+    @field_validator("autotuner", mode="before")
+    @classmethod
+    def _wrap_bare_string(cls, v: Any) -> Any:
+        if isinstance(v, str):
+            return {"type": v}
+        return v
+
+    k_max: int = 200
+    lam_prox: Union[float, Dict[str, Any]] = 1e-1
+    lam_vc: Union[float, Dict[str, Any]] = 1e0
+    lam_cost: Union[float, Dict[str, Any]] = 1e-2
+    lam_vb: float = 0.0
+    ep_tr: float = 1e-4
+    ep_vb: float = 1e-4
+    ep_vc: float = 1e-8
+
+    model_config = ConfigDict(extra="forbid", arbitrary_types_allowed=True)
+
+    def to_algorithm(
+        self,
+        states: Optional[List[Any]] = None,
+        controls: Optional[List[Any]] = None,
+    ) -> PenalizedTrustRegion:
+        at = self.autotuner
+        if at is None:
+            autotuner = None
+        elif isinstance(at, AutotuningBase):
+            autotuner = at
+        else:
+            autotuner = at.build()
+        kwargs = self.model_dump(exclude={"autotuner"}, exclude_unset=True)
+        return PenalizedTrustRegion(
+            autotuner=autotuner,
+            states=states,
+            controls=controls,
+            **kwargs,
+        )
+
+
+__all__ = [
+    # Base class
+    "Algorithm",
+    "AlgorithmState",
+    "DiscretizationResult",
+    "Weights",
+    # Core results
+    "OptimizationResults",
+    # PTR algorithm
+    "PenalizedTrustRegion",
+    "AutotuningBase",
+    "AugmentedLagrangian",
+    "ConstantProximalWeight",
+    "RampProximalWeight",
+    # Config models
+    "PenalizedTrustRegionConfig",
+    "AutotunerConfig",
+]

{openscvx-0.4.1.dev161 → openscvx-0.4.1.dev163}/openscvx/algorithms/augmented_lagrangian.py

@@ -1,9 +1,10 @@
 """Autotuning functions for SCP (Successive Convex Programming) parameters."""
 
 from copy import deepcopy
-from typing import TYPE_CHECKING, List
+from typing import TYPE_CHECKING, List, Literal
 
 import numpy as np
+from pydantic import BaseModel, ConfigDict
 
 from openscvx.config import Config
 from openscvx.utils.printing import (
@@ -364,3 +365,33 @@ class AugmentedLagrangian(AutotuningBase):
             adaptive_state = "Initial"
 
         return adaptive_state
+
+
+# =============================================================================
+# Pydantic spec for dict / YAML validation
+# =============================================================================
+
+
+class AugmentedLagrangianSpec(BaseModel):
+    """Validates AugmentedLagrangian configuration from dict/YAML input."""
+
+    type: Literal["AugmentedLagrangian"] = "AugmentedLagrangian"
+    rho_init: float = 1.0
+    rho_max: float = 1e2
+    gamma_1: float = 2.0
+    gamma_2: float = 0.5
+    eta_0: float = 1e-2
+    eta_1: float = 1e-1
+    eta_2: float = 0.8
+    ep: float = 0.99
+    eta_lambda: float = 1e1
+    lam_vc_max: float = 1e5
+    lam_prox_min: float = 1e-3
+    lam_prox_max: float = 1e4
+    lam_cost_drop: int = -1
+    lam_cost_relax: float = 1.0
+
+    model_config = ConfigDict(extra="forbid")
+
+    def build(self) -> AugmentedLagrangian:
+        return AugmentedLagrangian(**self.model_dump(exclude={"type"}, exclude_unset=True))

{openscvx-0.4.1.dev161 → openscvx-0.4.1.dev163}/openscvx/algorithms/base.py

@@ -119,8 +119,7 @@ class AutotuningBase(ABC):
     that are shared across different autotuning strategies (e.g., Penalized Trust
     Region, Augmented Lagrangian).
 
-    Subclasses should implement the `update_weights` method to define their specific
-    weight update strategy.
+    Subclasses must implement the ``update_weights`` method.
 
     Class Attributes:
         COLUMNS: List of Column specs for autotuner-specific metrics to display.

{openscvx-0.4.1.dev161 → openscvx-0.4.1.dev163}/openscvx/algorithms/constant_proximal_weight.py

@@ -1,6 +1,8 @@
 """Autotuning functions for SCP (Successive Convex Programming) parameters."""
 
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Literal
+
+from pydantic import BaseModel, ConfigDict
 
 from openscvx.config import Config
 
@@ -61,3 +63,21 @@ class ConstantProximalWeight(AutotuningBase):
         candidate.lam_prox = state.lam_prox
         state.accept_solution(candidate)
         return "Accept Constant"
+
+
+# =============================================================================
+# Pydantic spec for dict / YAML validation
+# =============================================================================
+
+
+class ConstantProximalWeightSpec(BaseModel):
+    """Validates ConstantProximalWeight configuration from dict/YAML input."""
+
+    type: Literal["ConstantProximalWeight"] = "ConstantProximalWeight"
+    lam_cost_drop: int = -1
+    lam_cost_relax: float = 1.0
+
+    model_config = ConfigDict(extra="forbid")
+
+    def build(self) -> ConstantProximalWeight:
+        return ConstantProximalWeight(**self.model_dump(exclude={"type"}, exclude_unset=True))

{openscvx-0.4.1.dev161 → openscvx-0.4.1.dev163}/openscvx/algorithms/ramp_proximal_weight.py

@@ -1,8 +1,9 @@
 """Autotuning functions for SCP (Successive Convex Programming) parameters."""
 
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Literal
 
 import numpy as np
+from pydantic import BaseModel, ConfigDict
 
 from openscvx.config import Config
 
@@ -77,3 +78,23 @@ class RampProximalWeight(AutotuningBase):
         else:
             state.accept_solution(candidate)
             return "Accept Higher"
+
+
+# =============================================================================
+# Pydantic spec for dict / YAML validation
+# =============================================================================
+
+
+class RampProximalWeightSpec(BaseModel):
+    """Validates RampProximalWeight configuration from dict/YAML input."""
+
+    type: Literal["RampProximalWeight"] = "RampProximalWeight"
+    ramp_factor: float = 1.0
+    lam_prox_max: float = 1e3
+    lam_cost_drop: int = -1
+    lam_cost_relax: float = 1.0
+
+    model_config = ConfigDict(extra="forbid")
+
+    def build(self) -> RampProximalWeight:
+        return RampProximalWeight(**self.model_dump(exclude={"type"}, exclude_unset=True))

{openscvx-0.4.1.dev161 → openscvx-0.4.1.dev163}/openscvx/config.py

@@ -1,7 +1,8 @@
-from dataclasses import dataclass, field, fields
-from typing import Optional
+from dataclasses import dataclass
+from typing import Any, ClassVar, Dict, Optional
 
 import numpy as np
+from pydantic import BaseModel, ConfigDict
 
 from openscvx.lowered.unified import UnifiedControl, UnifiedState
 
@@ -12,14 +13,13 @@ def get_affine_scaling_matrices(n, minimum, maximum):
     return S, c
 
 
-@dataclass
-class DevConfig:
+class DevConfig(BaseModel):
     """Configuration class for development settings.
 
     This class defines the parameters used for development and debugging
     purposes.
 
-    Args:
+    Attributes:
         profiling: Whether to enable profiling for performance
             analysis. Defaults to False.
         debug: Disables all precompilation so you can place
@@ -37,15 +37,16 @@ class DevConfig:
     printing: bool = True
     verbosity: int = 2
 
+    model_config = ConfigDict(extra="forbid")
 
-@dataclass
-class PropagationConfig:
+
+class PropagationConfig(BaseModel):
     """Configuration class for propagation settings.
 
     This class defines the parameters required for propagating the nonlinear
     system dynamics using the optimal control sequence.
 
-    Args:
+    Attributes:
         inter_sample: How dense the propagation within multishot
             discretization should be. Defaults to 30.
         dt: The time step for propagation. Defaults to 0.01.
@@ -63,10 +64,21 @@ class PropagationConfig:
     dt: float = 0.01
     solver: str = "Dopri8"
     max_tau_len: int = 1000
-    args: dict = field(default_factory=dict)
+    args: Dict[str, Any] = {}
     atol: float = 1e-3
     rtol: float = 1e-6
 
+    model_config = ConfigDict(extra="forbid")
+
+
+class SettingsSpec(BaseModel):
+    """Validates the ``settings:`` block from YAML/JSON input."""
+
+    dev: Optional[DevConfig] = None
+    prp: Optional[PropagationConfig] = None
+
+    model_config = ConfigDict(extra="forbid")
+
 
 @dataclass(init=False)
 class SimConfig:
@@ -224,7 +236,13 @@ class Config:
     dev: DevConfig
 
     # Subsections derived from the lowered problem — not user-configurable.
-    _INTERNAL_FIELDS = frozenset({"sim"})
+    _INTERNAL_FIELDS: ClassVar[frozenset] = frozenset({"sim"})
+
+    # Maps configurable section names to their pydantic model classes.
+    _SECTION_MODELS: ClassVar[Dict[str, type]] = {
+        "prp": PropagationConfig,
+        "dev": DevConfig,
+    }
 
     def apply_dict(self, settings: dict) -> None:
         """Apply a nested settings dict to this :class:`Config`.
@@ -232,25 +250,23 @@ class Config:
         Valid subsection names are discovered automatically from the
         dataclass fields (minus internal ones like ``sim``).
 
+        Each subsection is validated through its pydantic model, so
+        typos and wrong types are caught immediately (``extra="forbid"``).
+
         Example::
 
             config.apply_dict({
                 "dev": {"printing": False, "verbosity": 1},
             })
 
-        Dict values are handled contextually:
-
-        * If the target attribute is itself a ``dict`` (e.g.
-          ``solver_args``), the incoming dict **replaces** it.
-        * Otherwise the incoming dict **recurses** into the sub-object.
-
         Args:
             settings: ``{section: {key: value, ...}, ...}``
 
         Raises:
-            ValueError: On unknown section names or attribute names.
+            ValueError: On unknown section names.
+            ValidationError: On unknown keys or wrong types within a section.
         """
-        configurable = {f.name for f in fields(self)} - self._INTERNAL_FIELDS
+        configurable = set(self._SECTION_MODELS)
 
         for section, values in settings.items():
             if section not in configurable:
@@ -261,21 +277,8 @@ class Config:
                 raise ValueError(
                     f"Expected a mapping for settings.{section}, got {type(values).__name__}"
                 )
-            _apply_dict_to(getattr(self, section), values, prefix=section)
-
-
-def _apply_dict_to(obj: object, values: dict, prefix: str) -> None:
-    """Recursively apply *values* as attributes on *obj*.
-
-    * Plain values → ``setattr``.
-    * Dict values where the current attribute is a ``dict`` → ``setattr``
-      (replacement, e.g. ``solver_args``).
-    * Dict values where the current attribute is an object → recurse.
-    """
-    for key, val in values.items():
-        if not hasattr(obj, key):
-            raise ValueError(f"Unknown setting '{prefix}.{key}'")
-        if isinstance(val, dict) and not isinstance(getattr(obj, key), dict):
-            _apply_dict_to(getattr(obj, key), val, prefix=f"{prefix}.{key}")
-        else:
-            setattr(obj, key, val)
+            # Merge current values with overrides and re-validate through pydantic.
+            current = getattr(self, section)
+            model_cls = self._SECTION_MODELS[section]
+            updated = model_cls.model_validate({**current.model_dump(), **values})
+            setattr(self, section, updated)

openscvx-0.4.1.dev163/openscvx/discretization/__init__.py

@@ -0,0 +1,73 @@
+"""Discretization methods for trajectory optimization.
+
+This module provides implementations of discretization schemes that convert
+continuous-time optimal control problems into discrete-time approximations
+suitable for numerical optimization.
+
+Discretization and linearization are combined into a single interface
+(:class:`Discretizer`) because different schemes may linearize then discretize,
+discretize then linearize, or use other approaches. The ordering changes the
+intermediate types, but the input (continuous nonlinear dynamics + reference
+trajectory) and output (discrete-time linear matrices A_d, B_d, C_d) are
+always consistent.
+
+:class:`Problem` uses :class:`LinearizeDiscretizeSparse` by default (sparse
+Jacobians and compact variational integration when sparsity patterns exist).
+:class:`LinearizeDiscretize` is the dense linearize-then-discretize scheme.
+"""
+
+from typing import Any
+
+from .base import _DISCRETIZER_MAP, Discretizer, DiscretizerSpec, DisType
+from .discretize_linearize import DiscretizeLinearizeVectorize, VectorizeDiscretizeLinearize
+from .linearize_discretize import (
+    LinearizeDiscretize,
+    calculate_impulsive_discretization,
+    get_impulsive_discretization_solver,
+)
+from .linearize_discretize_sparse import LinearizeDiscretizeSparse
+from .sparse_utils import color_columns, make_sparse_jacobian_fns
+
+# ---------------------------------------------------------------------------
+# Populate the discretizer class map now that all classes are imported
+# ---------------------------------------------------------------------------
+
+_DISCRETIZER_MAP.update(
+    {
+        "VectorizeDiscretizeLinearize": VectorizeDiscretizeLinearize,
+        "DiscretizeLinearizeVectorize": DiscretizeLinearizeVectorize,
+        "LinearizeDiscretize": LinearizeDiscretize,
+        "LinearizeDiscretizeSparse": LinearizeDiscretizeSparse,
+    }
+)
+
+DEFAULT_DISCRETIZER_TYPE = "VectorizeDiscretizeLinearize"
+
+
+def resolve_discretizer_config(val: Any) -> DiscretizerSpec:
+    """Validate a dict/Spec into a :class:`DiscretizerSpec` instance.
+
+    Injects the default ``type`` (``VectorizeDiscretizeLinearize``) when the
+    input dict omits it, preserving backwards compatibility.
+    """
+    if isinstance(val, DiscretizerSpec):
+        return val
+    if isinstance(val, dict) and "type" not in val:
+        val = {**val, "type": DEFAULT_DISCRETIZER_TYPE}
+    return DiscretizerSpec.model_validate(val)
+
+
+__all__ = [
+    "DisType",
+    "Discretizer",
+    "DiscretizerSpec",
+    "DiscretizeLinearizeVectorize",
+    "LinearizeDiscretize",
+    "LinearizeDiscretizeSparse",
+    "VectorizeDiscretizeLinearize",
+    "resolve_discretizer_config",
+    "calculate_impulsive_discretization",
+    "color_columns",
+    "get_impulsive_discretization_solver",
+    "make_sparse_jacobian_fns",
+]