Merge pull request #421 from alphaville/fix/420-constraint-dimension

Constraint dimension checking and lazy imports

Author: alphaville

python/CHANGELOG.md

@@ -37,6 +37,8 @@ Note: This is the Changelog file of `opengen` - the Python interface of OpEn
 - ROS2 generated packages now use `uint16` for `error_code`, matching the current positive error-code range while keeping the wire format compact
 - MATLAB-related Python docs now reference the new `python/` package layout instead of the removed `open-codegen/` path
 - ROS2 integration tests now clean stale nested `colcon` build artifacts and preserve the active shell environment more reliably in micromamba/conda setups
+- Fixed issues in `__init__.py`: lazy imports and discoverability
+- Now checking whether the constraints have the correct dimension before attempting to build an optimizer
 
 
 ## [0.10.1] - 2026-03-25

python/opengen/__init__.py

@@ -1,7 +1,44 @@
-import opengen.definitions
-import opengen.builder
-import opengen.config
-import opengen.functions
-import opengen.constraints
-import opengen.tcp
-import opengen.ocp
+"""Top-level package for OpEn with lazy submodule imports.
+
+This module defers importing heavy subpackages to attribute access
+to avoid circular import problems during package initialization.
+
+Lazy submodule imports defer the loading of Python modules and their 
+attributes until they are first accessed, reducing startup time and 
+memory usage.  This is achieved using PEP 562 (__getattr__ and __dir__) 
+to intercept attribute access and load the underlying code only when 
+necessary.
+"""
+
+from importlib import import_module
+
+__all__ = [
+	"definitions",
+	"builder",
+	"config",
+	"functions",
+	"constraints",
+	"tcp",
+	"ocp",
+]
+
+
+def __getattr__(name):
+	"""Lazily import submodules on attribute access.
+
+	Example: accessing ``opengen.builder`` will import
+	``opengen.builder`` and cache it on the package module.
+
+	This defers importing heavy subpackages until they're actually used 
+	(lazy imports), reducing startup cost and helping avoid import-time 
+	circular dependencies.
+	"""
+	if name in __all__:
+		module = import_module(f"{__name__}.{name}")
+		globals()[name] = module
+		return module
+	raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+def __dir__():
+	return sorted(list(__all__) + list(globals().keys()))

python/opengen/builder/__init__.py

@@ -1,3 +1,12 @@
-from .optimizer_builder import *
-from .problem import *
-from .set_y_calculator import *
+from .optimizer_builder import OpEnOptimizerBuilder
+from .problem import Problem
+from .set_y_calculator import SetYCalculator
+from .ros_builder import RosBuilder, ROS2Builder
+
+__all__ = [
+	"OpEnOptimizerBuilder",
+	"Problem",
+	"SetYCalculator",
+	"RosBuilder",
+	"ROS2Builder",
+]

python/opengen/builder/optimizer_builder.py

@@ -1,7 +1,10 @@
+from __future__ import annotations
+
 import subprocess
 import shutil
 import yaml
 
+import opengen as og
 import opengen.config as og_cfg
 import opengen.definitions as og_dfn
 import opengen.constraints as og_cstr
@@ -43,10 +46,10 @@ class OpEnOptimizerBuilder:
     """
 
     def __init__(self,
-                 problem,
-                 metadata=og_cfg.OptimizerMeta(),
-                 build_configuration=og_cfg.BuildConfiguration(),
-                 solver_configuration=og_cfg.SolverConfiguration()):
+                 problem: og.builder.Problem,
+                 metadata: og_cfg.OptimizerMeta =og_cfg.OptimizerMeta(),
+                 build_configuration: og_cfg.BuildConfiguration =og_cfg.BuildConfiguration(),
+                 solver_configuration: og_cfg.SolverConfiguration=og_cfg.SolverConfiguration()):
         """Constructor of OpEnOptimizerBuilder
 
         :param problem: instance of :class:`~opengen.builder.problem.Problem`
@@ -645,6 +648,15 @@ def __initialize(self):
 
     def __check_user_provided_parameters(self):
         self.__logger.info("Checking user parameters")
+
+        # Check constraints dimensions
+        dim_constraints = self.__problem.constraints.dimension()        
+        dim_decision_variables = self.__problem.dim_decision_variables()
+        if dim_constraints is not None and dim_decision_variables != dim_constraints:
+            raise ValueError(f"Inconsistent dimensions - decision variables: {dim_decision_variables}", 
+                             f"set of constraints: {dim_constraints}")
+        
+        # Preconditioning...
         if self.__solver_config.preconditioning:
             # Preconditioning is not allowed when we have general ALM-type constraints of the form
             # F1(u, p) in C, unless C is {0} or an orthant (special case of rectangle).

python/opengen/config/__init__.py

@@ -1,5 +1,15 @@
-from .meta import *
-from .solver_config import *
-from .build_config import *
-from .tcp_server_config import *
-from .ros_config import *
+from .meta import OptimizerMeta, SEMVER_PATTERN
+from .solver_config import SolverConfiguration
+from .build_config import BuildConfiguration, RustAllocator
+from .tcp_server_config import TcpServerConfiguration
+from .ros_config import RosConfiguration
+
+__all__ = [
+	"OptimizerMeta",
+	"SEMVER_PATTERN",
+	"SolverConfiguration",
+	"BuildConfiguration",
+	"RustAllocator",
+	"TcpServerConfiguration",
+	"RosConfiguration",
+]

python/opengen/constraints/__init__.py

@@ -1,14 +1,31 @@
-from .ball1 import *
-from .ball2 import *
-from .sphere2 import *
-from .rectangle import *
-from .constraint import *
-from .ball_inf import *
-from .soc import *
-from .no_constraints import *
-from .cartesian import *
-from .zero import *
-from .finite_set import *
-from .halfspace import *
-from .simplex import *
-from .affine_space import *
+from .ball1 import Ball1
+from .ball2 import Ball2
+from .sphere2 import Sphere2
+from .rectangle import Rectangle
+from .constraint import Constraint
+from .ball_inf import BallInf
+from .soc import SecondOrderCone
+from .no_constraints import NoConstraints
+from .cartesian import CartesianProduct
+from .zero import Zero
+from .finite_set import FiniteSet
+from .halfspace import Halfspace
+from .simplex import Simplex
+from .affine_space import AffineSpace
+
+__all__ = [
+	"Ball1",
+	"Ball2",
+	"Sphere2",
+	"Rectangle",
+	"Constraint",
+	"BallInf",
+	"SecondOrderCone",
+	"NoConstraints",
+	"CartesianProduct",
+	"Zero",
+	"FiniteSet",
+	"Halfspace",
+	"Simplex",
+	"AffineSpace",
+]

python/opengen/constraints/affine_space.py

@@ -54,3 +54,6 @@ def is_compact(self):
         """Affine spaces are not compact sets
         """
         return False
+
+    def dimension(self):
+        return super().dimension()

python/opengen/constraints/ball1.py

@@ -73,3 +73,8 @@ def is_convex(self):
 
     def is_compact(self):
         return True
+
+    def dimension(self):
+        if self.center is None:
+            return None 
+        return len(self.center)

python/opengen/constraints/ball2.py

@@ -7,7 +7,7 @@
 class Ball2(Constraint):
     """A Euclidean ball constraint
 
-    A constraint of the form :math:`\|u-u_0\| \leq r`, where :math:`u_0` is the center
+    A constraint of the form :math:`\Vert u-u_0 \Vert \leq r`, where :math:`u_0` is the center
     of the ball and `r` is its radius
 
     """
@@ -91,3 +91,8 @@ def is_convex(self):
 
     def is_compact(self):
         return True
+
+    def dimension(self):
+        if self.center is None:
+            return None 
+        return len(self.center)

python/opengen/constraints/ball_inf.py

@@ -88,3 +88,8 @@ def is_convex(self):
 
     def is_compact(self):
         return True
+
+    def dimension(self):
+        if self.center is None:
+            return None 
+        return len(self.center)