Skip to content

Breaking API changes

The migration table for Python code, newest first: each breaking change with what replaces it. 0.36 is a breaking release and removes names outright, with no aliases and no deprecation warnings. The changelog is the release log, 0.35 → 0.36 the narrative migration with before/after examples, and 0.33 → 0.35 the earlier tesseract upgrades.

Release What breaks Use instead
0.36.0 Maps keyed by a link or joint (calcFwdKin, SceneState.link_transforms, getLinkTransforms, …) are dict[str, V]; 0.36.0.0rc1 keyed them by LinkId / JointId Index by name
0.36.0 Python modules lose the tesseract_ prefix (tesseract_robotics.tesseract_collision → tesseract_robotics.collision, 20 in all); the old names are gone and raise ModuleNotFoundError The new names
0.36.0 TaskComposer.plan raises ProfileTypeMismatchError when a Descartes node's namespace holds a profile only as the other scalar type (D for a Cartesian or raster pipeline); create_descartes_default_profiles(move_profile=…) refuses a Python subclass of DescartesMoveProfileD / F Register the type the node reads
0.36.0 Python 3.9, 3.10 and 3.11 are no longer supported; Rhino 8 loses wheels Python 3.12 or later, or 0.35.0.8
0.36.0 planning.program.Target and emitters.core.events.Event are type aliases, which isinstance rejects Their __value__, or the member classes
0.36.0 console_bridge logging API removed (setLogLevel, useOutputHandler, OutputHandler, CONSOLE_BRIDGE_LOG_*, …): upstream logs through spdlog getLogger(), addLogRecordHandler()
0.36.0 CollisionCoeffData.setPairCollisionCoeff / getPairCollisionCoeff removed The C++ names
0.36.0 CollisionCoeffData, TrajOptCollisionConfig, SQPParameters compare by value and are unhashable A stable key, or id()
0.36.0 A collision constraint on a Var outside a NodesVariables raises VarNotInVariableSetError (a ValueError) at construction instead of segfaulting on its first update() Hand the Node over first
0.36.0 Node.getParent raises NodeParentUnavailableError for planner-owned nodes, including inside create overrides Keep the planner's Nodes, not their set
0.36.0 OSQPEigenSolver.update* raise QPSizeError on a wrong-length vector Size by init()
0.36.0 16 command-language waypoint, instruction and Poly types compare by value and are unhashable A stable key, or id()
0.36.0 TOTGCompositeProfile, ISPCompositeProfile, ISPMoveProfile, ConstantTCPSpeedCompositeProfile compare by value and are unhashable A stable key, or id()
0.36.0 The seven simple-planner move profiles compare by value and are unhashable A stable key, or id()
0.36.0 OMPLSolverConfig.getNumPlanners() removed len(cfg.planners)
0.36.0 OMPL, TrajOpt and task-composer planning value types compare by value and are unhashable A stable key, or id()
0.36.0 create_ompl_planner_configurators raises ValueError on a keyword none of the requested planners has Drop the keyword
0.36.0 7 TrajOpt-Ifopt and Descartes profiles and waypoint configs compare by value and are unhashable A stable key, or id()
0.36.0 Overriding a hook (generate, create, create*) on a Python subclass of a concrete profile raises ProfileOverrideNotDispatchedError at class definition; the override was silently never called Subclass the abstract base and hold the concrete profile
0.36.0 TaskComposerPluginFactory(str, locator) and TaskComposerServer.loadConfig(str, locator) read the str as YAML text A pathlib.Path
0.36.0 createTaskComposerPluginFactory, createTaskComposerDataStorage, TaskComposerKeys.addKeys, TaskComposerDataStorage.getAllData, TaskComposerNodeInfoContainer.getAllInfos / getAbortingNodeInfo and the container overloads of getDotgraph / saveDotgraph removed The C++ names
0.36.0 TaskComposerNode.saveDotgraph raises OSError instead of returning False, and returns None Catch OSError
0.36.0 TaskComposerKeys.get of a list port returns list[str]; TaskComposerNodeInfo fields are writable Task composer value types
0.36.0 AnyPoly, TaskComposerKeys, TaskComposerDataStorage, TaskComposerNodeInfo, TaskComposerNodeInfoContainer, TaskComposerContext, TaskComposerNodePorts, TaskComposerLog compare by value and are unhashable A stable key, or id()
0.36.0 command_language.MoveInstructionType_* constants removed The MoveInstructionType members
0.36.0 MoveInstruction(Poly).assign{Cartesian,Joint,State}Waypoint, ProfileDictionary_addProfile removed setWaypoint, addProfile
0.36.0 *_wrap_*, InstructionPoly_as_*, WaypointPoly_as_*, CompositeInstruction.appendMoveInstruction removed; wp.as…Waypoint() is a reference Constructors and as…() methods
0.36.0 TOTGCompositeProfile, ISPCompositeProfile, ISPMoveProfile, ConstantTCPSpeedCompositeProfile renamed The C++ names
0.36.0 SQPStatus.NLP_CONVERGED, OPT_TIME_LIMIT, QP_SOLVER_ERROR, CALLBACK_STOPPED, QPSolverStatus.UNITIALIZED, QP_ERROR renamed The C++ names
0.36.0 ProfileDictionary_add*, *_as_ProfileConstPtr, cast_Descartes*, the …PlanProfile aliases and motion_planners_trajopt.TrajOptCollisionConfig / CollisionEvaluatorType removed addProfile and the …MoveProfile names
0.36.0 create_time_optimal_parameterization(path_tolerance, min_angle_change), create_iterative_spline_parameterization(add_points): the ignored arguments are removed Set the composite profile's fields
0.36.0 tesseract_robotics.ompl_base and tesseract_reeds_shepp_example removed ompl_base removed
0.36.0 ChangeCollisionMarginsCommand(pair_margin_data) merges the pair margins (MODIFY) instead of replacing them Pass REPLACE
0.36.0 MotionProgram / get_manipulator_info require tcp_frame and working_frame; fk / ik require tip_link; to_composite_instruction has no tcp_frame Name the frames
0.36.0 geometry.PointCloudPoint renamed PointCloud.Point
0.36.0 scene_graph.JointType_* constants removed The JointType members
0.36.0 37 collision, common and environment value types compare by value and are unhashable: hash(), set members and dict keys raise TypeError A stable key, or id()
0.36.0 TaskComposerPluginFactory.createTaskComposerNode / createTaskComposerExecutor no longer return None except TaskComposerPluginError
0.36.0 margin_data_override_type, set{Default,Pair}CollisionMarginData, CollisionMarginOverrideType, get/setPairCollisionMargin removed The tesseract names
0.36.0 ContactTestType_*, Events_*, ModifyAllowedCollisionsType_* and module-level CONSOLE_BRIDGE_LOG_* constants removed The enum members
0.36.0 environment.AnyPoly_wrap_EnvironmentConst, command_language.AnyPoly_* and _HAS_TASK_COMPOSER removed task_composer.AnyPoly_*
0.36.0 FilesystemPath, _FilesystemPath, TransformMap, Environment.initFromUrdf / initFromUrdfSrdf removed; Environment.init(str, …) is content pathlib.Path
0.36.0 evaluateConvexCosts, evaluateTotalConvexCost, evaluateConvexConstraintViolations raise QPSolutionSizeError (a ValueError) on a var_vals that is not getNumQPVars() long The QP solution vector
0.36.0 trajopt_sqp.IfoptQPProblem and trajopt_sqp.IfoptProblem removed TrajOptQPProblem
0.36.0 Quaterniond(w, x, y, z) and Quaterniond(coeffs=) removed from_xyzw, Quaterniond([x, y, z, w])
0.36.0 environment.EventCallbackFn removed; addEventCallback(fn) returns the key; removeEventCallback(hash=) is key=; getJointGroup(name=) is group_name= Environment events and keywords
0.36.0 Environment.getStateByMap, getStateByNamesAndValues, setStateByNamesAndValues, getCurrentJointValuesByNames, StateSolver.setStateByMap / setStateByNamesAndValues, JointGroup.calcJacobianWithPoint, KinematicGroup.calcInvKinMultiple removed The native overloads
0.36.0 common.VectorVector3d and VectorIsometry3d removed Plain lists
0.36.0 Missing ids raise KeyError; as*Instruction() return views and a wrong cast raises PolyTypeError; applyCommand is one overload Errors and views
0.36.0 Isometry3d(matrix) takes rotations only (NotRotationError); a zero quaternion or axis raises DegenerateRotationError; Hyperplane3d.Through follows Eigen Geometry inputs
0.36.0 serialization.*_to_file return None and raise OSError; binary archives are bytes; urdf.writeURDFFile returns the path and raises URDFWriteError Files and bytes
0.36.0 A plugin-factory config path the locator cannot resolve raises FileNotFoundError; trajopt_ifopt is a package; Python constraint and Descartes profile errors are named Named errors
0.36.0 Robot.ik raises IKNoSolutionError; Robot mutators return None and raise EnvironmentCommandError; planning failures are named exceptions Planning errors
0.36.0 MotionProgram.start_at, create_descartes_pipeline_profiles, TRAJOPT_PROFILE_NAMES, CartesianTarget(position=, quaternion=), TaskComposer(config_path=) removed; _create_trajopt_profiles is create_trajopt_profile_pair Planning names
0.36.0 TaskComposer.plan raises for programming and configuration errors; plan_ompl defaults to FreespacePipeline; a pipeline without default profiles raises NoDefaultProfilesError Plan errors
0.36.0 get_tesseract_resource_path has one source (the support wheel); __version__ has no placeholder; from scene_graph import * omits SceneState; planning, common, scene_graph have no __all__ Package surface
0.36.0 Examples' main() raise PlanningFailedError when a plan fails Examples
0.36.0 Emitters take frames from the ManipulatorInfo (frames=, UnboundFrameError); emit_rapid returns an EmittedProgram and needs a posture solver for confdata; JBI needs a JbiPulseCalibration; SetToolInstruction raises; names are validated Emitters
0.35.0.1 planning.Transform removed; Pose is an Isometry3d Pose
0.35.0.1 tesseract 0.35: package://tesseract_support/ resource URIs package://tesseract/support/
0.34.1.0 tesseract 0.34: ifopt module, JointPosition, CartPosInfo, CollisionCache, … 0.33 → 0.34 guide

0.36.0

0.36 module names

The tesseract_ prefix is gone from 20 Python module names (issue #42). It repeated the package name (tesseract_robotics.tesseract_collision).

Old (deprecated) New
tesseract_robotics.tesseract_collision tesseract_robotics.collision
tesseract_robotics.tesseract_command_language tesseract_robotics.command_language
tesseract_robotics.tesseract_common tesseract_robotics.common
tesseract_robotics.tesseract_environment tesseract_robotics.environment
tesseract_robotics.tesseract_geometry tesseract_robotics.geometry
tesseract_robotics.tesseract_kinematics tesseract_robotics.kinematics
tesseract_robotics.tesseract_motion_planners tesseract_robotics.motion_planners
tesseract_robotics.tesseract_motion_planners_descartes tesseract_robotics.motion_planners_descartes
tesseract_robotics.tesseract_motion_planners_ompl tesseract_robotics.motion_planners_ompl
tesseract_robotics.tesseract_motion_planners_simple tesseract_robotics.motion_planners_simple
tesseract_robotics.tesseract_motion_planners_trajopt tesseract_robotics.motion_planners_trajopt
tesseract_robotics.tesseract_motion_planners_trajopt_ifopt tesseract_robotics.motion_planners_trajopt_ifopt
tesseract_robotics.tesseract_scene_graph tesseract_robotics.scene_graph
tesseract_robotics.tesseract_serialization tesseract_robotics.serialization
tesseract_robotics.tesseract_srdf tesseract_robotics.srdf
tesseract_robotics.tesseract_state_solver tesseract_robotics.state_solver
tesseract_robotics.tesseract_task_composer tesseract_robotics.task_composer
tesseract_robotics.tesseract_task_composer_planning tesseract_robotics.task_composer_planning
tesseract_robotics.tesseract_time_parameterization tesseract_robotics.time_parameterization
tesseract_robotics.tesseract_urdf tesseract_robotics.urdf

trajopt_ifopt, trajopt_sqp, planning, viewer and emitters keep their names.

Python
# before
from tesseract_robotics.tesseract_collision import ContactRequest
from tesseract_robotics.tesseract_common import Isometry3d
Python
# after
from tesseract_robotics.collision import ContactRequest
from tesseract_robotics.common import Isometry3d

No aliases. 0.36 is a breaking release: the old names are gone, and importing one raises ModuleNotFoundError. Every class, enum and function keeps its name; only the module path changes.

Layout. Sixteen modules (14 of the renamed ones, plus trajopt_ifopt and trajopt_sqp) are the compiled extension itself, installed as tesseract_robotics/<name>.abi3.so with a <name>.pyi stub and no __init__.py wrapper. The other six keep a Python package around a compiled _<name> module because they hold Python code: common (axis constants), scene_graph (lazy SceneState re-export), and motion_planners, motion_planners_simple, motion_planners_descartes and motion_planners_trajopt_ifopt (profile-override guards). Both layouts import the same way. The C++ binding sources moved from src/tesseract_<name>/tesseract_<name>_bindings.cpp to src/bindings/<name>.cpp; build scripts and forks that name the old paths need the new ones. Upstream C++ names (the tesseract_collision:: namespaces, find_package(tesseract_collision), the headers) did not change.

0.36.0.0rc1 returned every map keyed by a link or joint as dict[LinkId, V] / dict[JointId, V]. A str lookup worked at runtime but no type checker accepts it, so 0.36.0 returns dict[str, V] keyed by name, as 0.35 did: calcFwdKin, SceneState.joints / floating_joints / link_transforms / joint_transforms, getLinkTransforms(ids, values), getCurrentFloatingJointValues, getFloatingJointValues, the joint-limit commands' getLimits, ContactManagerConfig.modify_object_enabled, KinematicsInformation.group_states / group_tcps, CalibrationInfo.joints and the keys of SceneGraph.getAdjacencyMap. Inputs accept names or ids as keys. LinkIdPair-keyed maps are unchanged.

before (0.36.0.0rc1) after
poses[LinkId("tool0")] poses["tool0"]
{lid.name(): tf for lid, tf in state.link_transforms.items()} state.link_transforms
[jid.name() for jid in state.joints] list(state.joints)
Python
# 0.36.0.0rc1
poses = robot.env.getState().link_transforms   # dict[LinkId, Isometry3d]
names = [lid.name() for lid in poses]
Python
# 0.36.0
poses = robot.env.getState().link_transforms   # dict[str, Isometry3d]
names = list(poses)
tool0 = poses["tool0"]

Descartes profiles match the node's scalar type

A Descartes node reads only the profiles of its own scalar type, and runs the library defaults when it finds none (#350):

Pipeline Descartes node Reads
CartesianPipeline, DescartesFPipeline, DescartesFNPCPipeline, every Raster* pipeline DescartesFMotionPlannerTaskFactory DescartesMoveProfileF, DescartesSolverProfileF
DescartesDPipeline, DescartesDNPCPipeline (the plan_cartesian default) DescartesDMotionPlannerTaskFactory DescartesMoveProfileD, DescartesSolverProfileD

Only the D types were bound, so a profile never reached a Cartesian or raster task: the pipeline planned with the defaults (target pose fixed, no vertex margin) and reported success. TaskComposer.plan now raises ProfileTypeMismatchError (a TypeError) before it runs when a profile name in a Descartes node's namespace holds the other type's move or solver profile but not the node's own. The profile helpers register both types, and a namespace may hold both.

create_descartes_default_profiles(move_profile=…) registers the profile with its twin of the other type, copied field by field. A Python subclass of DescartesMoveProfileD or ...F has hooks no twin can call, so the helper refuses it with ProfileOverrideNotDispatchedError:

before after
profiles.addProfile(ns, name, DescartesDefaultMoveProfileD()), planned with CartesianPipeline create_descartes_default_profiles(move_profile=profile), or add a DescartesDefaultMoveProfileF too
create_descartes_default_profiles(move_profile=MyMoveProfile()), MyMoveProfile(DescartesMoveProfileD) profiles.addProfile("DescartesMotionPlannerTask", name, MyMoveProfile()) for a D pipeline; subclass DescartesMoveProfileF for a Cartesian or raster one

Python 3.12 is the minimum

requires-python is >=3.12. One cp312-abi3 wheel per platform installs on CPython 3.12, 3.13 and 3.14, so Rhino 9 (CPython 3.13) is covered. Rhino 8 embeds CPython 3.9 and has no newer wheels:

Bash
pip install "tesseract-robotics-nanobind==0.35.0.8"  # Rhino 8, Python 3.9 (macOS, Windows); Python 3.10-3.11

pip picks that release by itself on those Pythons, because later ones declare the floor.

Target and Event are type aliases

planning.program.Target and emitters.core.events.Event use the type statement. Annotations are unaffected; isinstance(x, Target) raises TypeError.

Python
from tesseract_robotics.planning import CartesianTarget, JointTarget, StateTarget

isinstance(x, (CartesianTarget, JointTarget, StateTarget))

Target.__value__ is the union, for code that introspects it.

setPairCollisionCoeff and getPairCollisionCoeff removed

trajopt_ifopt.CollisionCoeffData bound two copies of its setter and getter under names C++ does not have (#298). Call the C++ names:

before after
data.setPairCollisionCoeff(a, b, c) data.setCollisionCoeff(a, b, c)
data.getPairCollisionCoeff(a, b) data.getCollisionCoeff(a, b)

trajopt value types compare by value and are unhashable

trajopt_ifopt.CollisionCoeffData, trajopt_ifopt.TrajOptCollisionConfig and trajopt_sqp.SQPParameters bind __eq__/__ne__ from their C++ operator== and set __hash__ = None (#261), as the collision, common and environment types do. CollisionCoeffData() == CollisionCoeffData() was False. hash(obj), {obj} and d[obj] = … now raise TypeError: unhashable type:

before after
seen = {config} seen = {id(config)}
cache[params] = result key on the fields you vary, e.g. cache[params.max_iter] = result

Collision constraints need a Var in a variable set

trajopt's collision constraints key their contact cache on the variable set's hash, which they read through var.getParent().getParent() without a check: a Var outside a NodesVariables dereferenced null on the first update(). DiscreteCollisionConstraint, DiscreteCollisionConstraintD, DiscreteCollisionNumericalConstraint, ContinuousCollisionConstraint, ContinuousCollisionConstraintD and ContinuousCollisionNumericalConstraint now raise VarNotInVariableSetError (a ValueError) at construction (#297). A Var from createNodesVariables always qualifies; one from Node.addVar qualifies once its Node is handed to NodesVariables:

before after
var = node.addVar(...); DiscreteCollisionConstraint(evaluator, var); NodesVariables("t", [node]) var = node.addVar(...); NodesVariables("t", [node]); DiscreteCollisionConstraint(evaluator, var)

Node.getParent raises for planner-owned nodes

A Python TrajOptIfoptCompositeProfile.create receives the planner's Nodes, whose variable set the planner builds in C++ and frees when its solve returns. Node.getParent() on such a Node returned a view of that set, which read freed memory once the solve was over (#297). It now raises NodeParentUnavailableError (a RuntimeError) for every Node of a set C++ owns, during create too. getParent() still returns the set for Nodes of a set built from Python:

before after
nodes[0].getParent().getRows() in create read what create needs from the Nodes themselves: sum(node.size() for node in nodes)

OSQPEigenSolver updates check sizes

updateGradient, updateLowerBound, updateUpperBound and updateBounds now sit on QPSolver and raise QPSizeError (a ValueError) unless the vector has init()'s num_vars (gradient) or num_cnts (bounds) entries (#283). trajopt checked with assert only and read past a short vector. Call init(num_vars, num_cnts) with the QP's size before the updates.

Command-language types compare by value and are unhashable

The command-language waypoints, instructions and Polys compared by identity: two JointWaypoint(["a"], [1.0]) were unequal. They now bind __eq__/__ne__ from the C++ operators and set __hash__ = None, as the collision, common and environment types do (#261): CartesianWaypoint, JointWaypoint, StateWaypoint, WaypointPoly, CartesianWaypointPoly, JointWaypointPoly, StateWaypointPoly, InstructionPoly, MoveInstructionPoly, MoveInstruction, CompositeInstruction, WaitInstruction, TimerInstruction, SetAnalogInstruction, SetDigitalInstruction, SetToolInstruction.

hash(obj), {obj} and d[obj] = … now raise TypeError: unhashable type. Every instruction has a UUID, which is the natural key; MoveInstruction equality also compares it, so two moves built separately are unequal until the UUIDs match:

before after
seen = {move} seen = {move.getUUID()}
cache[waypoint] = result cache[id(waypoint)] = result (keep waypoint alive)
move in done meant identity any(m is move for m in done); in now compares values

Time-parameterization profiles compare by value and are unhashable

The four time-parameterization profiles were bound without their C++ operator==, so == compared identity: TOTGCompositeProfile() == TOTGCompositeProfile() was False. They now bind __eq__/__ne__ and set __hash__ = None (#261), as the collision, common and environment value types do. The new RuckigTrajectorySmoothingCompositeProfile behaves the same way.

before after
{TOTGCompositeProfile(): …}, set_of_profiles.add(p) key by name, e.g. {"DEFAULT": p}, or by id(p)
p == q (identity) p is q

Simple-planner move profiles compare by value and are unhashable

SimplePlannerFixedSize{,Assign,AssignNoIK}MoveProfile and SimplePlannerLVS{,NoIK,Assign,AssignNoIK}MoveProfile bind the C++ operator== (#261): two profiles with the same fields are ==, and hash(), set members and dict keys raise TypeError, as for the collision, common and environment value types.

before after
{profile: name} {id(profile): name}, or key by the profile name
profile in seen_set (identity) any(p is profile for p in seen)

OMPLSolverConfig.getNumPlanners() removed

OMPLSolverConfig.planners is bound (#302), so the count is len(cfg.planners). The list is copied on access; its configurators are shared with the config. cfg.planners.append(x) changes the copy, but cfg.planners[0].range = 0.5 edits the config. Assign a new list, or use addPlanner / clearPlanners, which change it in place.

before after
cfg.getNumPlanners() len(cfg.planners)

Planner value types compare by value and are unhashable

As for collision, common and environment, these classes bind the C++ operator== and set __hash__ = None (#261). hash(), set members and dict keys raise TypeError:

module classes
motion_planners_ompl OMPLSolverConfig, OMPLRealVectorMoveProfile
motion_planners_trajopt TrajOptCartesianWaypointConfig, TrajOptJointWaypointConfig, TrajOptDefaultMoveProfile, TrajOptDefaultCompositeProfile, TrajOptOSQPSolverProfile, BasicTrustRegionSQPParameters (and the new OSQPSettings)
task_composer_planning ContactCheckProfile, FixStateBoundsProfile, FixStateCollisionProfile, KinematicLimitsCheckProfile, MinLengthProfile, ProfileSwitchProfile, UpsampleTrajectoryProfile

Key on a field, or on id(obj) where identity is meant, as in the value-types entry. OMPLSolverConfig compares planners by count only (upstream ompl_solver_config.cpp), so two configs holding different configurator types of the same number are equal.

create_ompl_planner_configurators rejects unused keywords

The helper accepts every OMPLPlannerType name (#301) and sets each keyword on the requested configurators that have that field. It used to ignore a keyword no configurator used; now it raises ValueError naming the keyword. A keyword that fits at least one requested planner is still accepted (goal_bias with ["RRTConnect", "RRTstar"] sets it on the RRTstar ones).

before after
create_ompl_planner_configurators(["RRTConnect"], goal_bias=0.1) create_ompl_planner_configurators(["RRTConnect"])

TrajOpt-Ifopt and Descartes profiles compare by value and are unhashable

These classes bind __eq__/__ne__ from their C++ operator== and set __hash__ = None, as the collision, common and environment value types do (#261):

| motion_planners_trajopt_ifopt | TrajOptIfoptCartesianWaypointConfig, TrajOptIfoptJointWaypointConfig, TrajOptIfoptDefaultMoveProfile, TrajOptIfoptDefaultCompositeProfile, TrajOptIfoptOSQPSolverProfile | | motion_planners_descartes | DescartesDefaultMoveProfileD, DescartesLadderGraphSolverProfileD |

hash(profile), {profile} and d[profile] = … raise TypeError: unhashable type. Key on the profile's name in the ProfileDictionary, or on id(profile) where identity is what you mean:

| seen = {profile} | seen = {profile_name} | | cache[profile] = result | cache[id(profile)] = result (keep profile alive) |

Overriding a hook on a concrete profile raises

Only the abstract profile bases forward the planner's calls to Python. A Python subclass of a concrete profile (the seven simple-planner move profiles, TrajOptIfoptDefaultMoveProfile, TrajOptIfoptDefaultCompositeProfile, TrajOptIfoptOSQPSolverProfile, DescartesDefaultMoveProfileD, DescartesLadderGraphSolverProfileD) that defined generate, create or a create* hook planned with the C++ hook and never ran the override. Such a class statement now raises ProfileOverrideNotDispatchedError, a TypeError (#340):

before after
class P(SimplePlannerLVSMoveProfile): def generate(...) class P(SimplePlannerMoveProfile), holding a SimplePlannerLVSMoveProfile and calling its generate
class P(TrajOptIfoptDefaultCompositeProfile): def create(...) class P(TrajOptIfoptCompositeProfile), holding a TrajOptIfoptDefaultCompositeProfile and calling its create
class P(TrajOptIfoptOSQPSolverProfile): def create(...) configure the solver through the profile's fields and callbacks

A subclass that defines no hook (to add fields or helpers) is unaffected.

TaskComposerPluginFactory: a str is YAML text

The factory bound one constructor, (config: str, locator), and passed the string to the C++ path constructor, while KinematicsPluginFactory, ContactManagersPluginFactory and Environment.init read a str as content. It now binds both C++ constructors the same way: an os.PathLike (pathlib.Path) is a config file, a str is YAML text. A path passed as str parses as a YAML scalar and raises TaskComposerConfigError (a ValueError) naming the text. loadConfig and the new TaskComposerServer.loadConfig take the same pair (#337, #323).

before after
TaskComposerPluginFactory(str(p), loc) TaskComposerPluginFactory(Path(p), loc)
createTaskComposerPluginFactory(str(p), loc) TaskComposerPluginFactory(Path(p), loc)

Task-composer compatibility helpers removed

Python-only names that duplicated a constructor, or stood in for C++ API that is now bound under its own name (#313, #314, #336, #338):

before after
createTaskComposerDataStorage() TaskComposerDataStorage()
createTaskComposerPluginFactory(p, loc) TaskComposerPluginFactory(Path(p), loc)
keys.addKeys(port, ["a", "b"]) keys.add(port, ["a", "b"])
storage.getAllData() storage.getData()
infos.getAllInfos() list(infos.getInfoMap().values())
infos.getAbortingNodeInfo() infos.getInfo(infos.getAbortingNode()) (None when nothing aborted)
node.getDotgraph(infos) node.getDotgraph(infos.getInfoMap())
node.saveDotgraph(path, infos) node.saveDotgraph(path, infos.getInfoMap())
task_composer.__all__ the module's attributes (from … import * still works)

TaskComposerNode.saveDotgraph raises OSError

saveDotgraph returned False when the file could not be opened or written, which a caller that ignored the result never saw. It now raises OSError (FileNotFoundError for a missing directory) and returns None, as TaskComposerPluginFactory.saveConfig does, and takes a str or an os.PathLike (#316).

before after
if not node.saveDotgraph(path): ... try: node.saveDotgraph(path) / except OSError: ...

Task-composer value types compare by value and are unhashable

As for the collision, common and environment types: AnyPoly, TaskComposerKeys, TaskComposerDataStorage, TaskComposerNodeInfo, TaskComposerNodeInfoContainer, TaskComposerContext, TaskComposerNodePorts and TaskComposerLog bind C++ operator==, so == compares content, and hash(), set members and dict keys raise TypeError (#261). Two AnyPoly holding separately built instructions are unequal: an instruction's uuid takes part in its equality.

TaskComposerKeys.get(port) returns what the port holds, str or list[str]; it raised RuntimeError for a list port before (#313). TaskComposerNodeInfo's fields are read-write (#319).

SWIG-era MoveInstructionType_* constants removed

command_language no longer exports a module constant per MoveInstructionType value. The three constants were copies kept from the SWIG bindings; C++ has none of them, and MoveInstructionType is bound as an enum whose members are the same objects (#275, as #176 and

214 did for the other modules). Importing one now raises

ImportError: cannot import name 'MoveInstructionType_LINEAR' from 'tesseract_robotics.command_language'; reading one as an attribute raises AttributeError.

The package's __all__ list is gone as well: from tesseract_robotics.command_language import * now exports every public name of the extension instead of a hand-kept subset.

before after
MoveInstructionType_LINEAR (also _FREESPACE, _CIRCULAR) MoveInstructionType.LINEAR (.FREESPACE, .CIRCULAR)
from tesseract_robotics.command_language import MoveInstructionType_LINEAR from tesseract_robotics.command_language import MoveInstructionType

assign*Waypoint and ProfileDictionary_addProfile removed

Seven Python-only names duplicated a bound method (#276). assignCartesianWaypoint, assignJointWaypoint and assignStateWaypoint on MoveInstruction and MoveInstructionPoly did what setWaypoint does; C++ 0.33 removed them. ProfileDictionary_addProfile worked around a cross-module limitation that no longer exists: ProfileDictionary.addProfile accepts a profile from any planner module, including a Python subclass of a trampolined profile.

before after
mi.assignCartesianWaypoint(wp) (also assignJointWaypoint, assignStateWaypoint) mi.setWaypoint(wp)
ProfileDictionary_addProfile(d, ns, name, profile) d.addProfile(ns, name, profile)

SWIG-era Poly helpers and appendMoveInstruction removed

command_language kept 15 Python-only names from the SWIG bindings (#328). Each duplicated a constructor or method; C++ has none of them. Importing one raises ImportError, calling appendMoveInstruction raises AttributeError.

before after
CartesianWaypointPoly_wrap_CartesianWaypoint(wp) CartesianWaypointPoly(wp)
JointWaypointPoly_wrap_JointWaypoint(wp) JointWaypointPoly(wp)
StateWaypointPoly_wrap_StateWaypoint(wp) StateWaypointPoly(wp)
MoveInstructionPoly_wrap_MoveInstruction(mi) MoveInstructionPoly(mi)
InstructionPoly_as_MoveInstructionPoly(ip) ip.asMoveInstruction()
InstructionPoly_as_CompositeInstruction(ip) ip.asCompositeInstruction()
InstructionPoly_as_WaitInstruction(ip) (also Timer, SetAnalog, SetDigital, SetTool) ip.asWaitInstruction() (asTimerInstruction(), …)
WaypointPoly_as_CartesianWaypointPoly(wp) wp.asCartesianWaypoint()
WaypointPoly_as_JointWaypointPoly(wp) wp.asJointWaypoint()
WaypointPoly_as_StateWaypointPoly(wp) wp.asStateWaypoint()
program.appendMoveInstruction(mi) program.push_back(mi)

Reference, not copy. WaypointPoly_as_* returned a copy of the stored waypoint; wp.as…Waypoint() returns a reference into it. An edit through the result now changes the waypoint, and so the program that holds it:

Python
import copy

mi.getWaypoint().asCartesianWaypoint().setTransform(target)  # edits mi
snapshot = copy.copy(mi.getWaypoint().asCartesianWaypoint())  # an independent copy

InstructionPoly.as…() returns a copy, as the helpers did.

Time-parameterization profiles renamed to their C++ names

The four time-parameterization profiles were bound under abbreviated names. They now carry their C++ names, as every other planner profile does (#329, following #187). There is no alias: importing an old name raises ImportError. The time_parameterization package's __all__ list, which named the old classes, is gone as well.

before after
TOTGCompositeProfile TimeOptimalTrajectoryGenerationCompositeProfile
ISPCompositeProfile IterativeSplineParameterizationCompositeProfile
ISPMoveProfile IterativeSplineParameterizationMoveProfile
ConstantTCPSpeedCompositeProfile ConstantTCPSpeedParameterizationCompositeProfile

The earlier entries for these profiles (value equality, createKey(), minimum_time_delta) apply under the new names.

Six trajopt_sqp enumerators renamed to their C++ names

trajopt 0.34 renamed its enumerators to kCamelCase; the bindings kept the old Python names. For most of them the old name already was the UPPER_SNAKE form of the C++ name (kRunning → RUNNING). For six it was not, so they now follow the same rule (#330). There are no aliases. Code that reads an old member raises AttributeError; code that compares status.name to an old string (status.name == "NLP_CONVERGED") no longer matches and raises nothing, so search for the strings as well as the attributes.

before after
SQPStatus.NLP_CONVERGED SQPStatus.CONVERGED
SQPStatus.OPT_TIME_LIMIT SQPStatus.TIME_LIMIT
SQPStatus.QP_SOLVER_ERROR SQPStatus.QP_SOLVE_FAILED
SQPStatus.CALLBACK_STOPPED SQPStatus.STOPPED_BY_CALLBACK
QPSolverStatus.UNITIALIZED QPSolverStatus.UNINITIALIZED
QPSolverStatus.QP_ERROR QPSolverStatus.FAILED

Planner-module compatibility names removed

The four planner modules kept names from older APIs that C++ does not have (#334, #335). They are gone with no deprecation cycle, as in #176 and #214. Importing one raises ImportError.

Profile helpers (#334). Each one either put a profile in a ProfileDictionary or upcast it to Profile so it could go in. ProfileDictionary.addProfile takes every planner's profiles directly, including a Python subclass of DescartesMoveProfileD:

before after
ProfileDictionary_addOMPLProfile(pd, ns, name, p), ProfileDictionary_addOMPLMoveProfile(…) pd.addProfile(ns, name, p)
ProfileDictionary_addTrajOpt{Move,Plan,Composite,Solver}Profile(pd, ns, name, p) pd.addProfile(ns, name, p)
ProfileDictionary_addTrajOptIfopt{Move,Plan,Composite,Solver}Profile(pd, ns, name, p) pd.addProfile(ns, name, p)
OMPLMoveProfile_as_ProfileConstPtr(p), OMPLPlanProfile_as_ProfileConstPtr(p) p
cast_DescartesMoveProfileD(p), cast_DescartesPlanProfileD(p), cast_DescartesSolverProfileD(p) p

0.28 profile names (#335). Tesseract 0.33 renamed the planner move profiles; the old names were kept as aliases:

before after
OMPLPlanProfile OMPLMoveProfile
OMPLRealVectorPlanProfile OMPLRealVectorMoveProfile
TrajOptPlanProfile TrajOptMoveProfile
TrajOptDefaultPlanProfile TrajOptDefaultMoveProfile
TrajOptIfoptPlanProfile TrajOptIfoptMoveProfile
TrajOptIfoptDefaultPlanProfile TrajOptIfoptDefaultMoveProfile
DescartesPlanProfileD DescartesMoveProfileD
DescartesDefaultPlanProfileD DescartesDefaultMoveProfileD

trajopt's 0.28 re-exports (#335). motion_planners_trajopt no longer re-exports TrajOptCollisionConfig or CollisionEvaluatorType. Import them from their own modules, tesseract_robotics.trajopt_ifopt and tesseract_robotics.collision. motion_planners_trajopt_ifopt keeps its re-exports (TrajOptCollisionConfig, CollisionEvaluatorType, SQPParameters), so its profile fields are still configured from one import.

__all__ (#335). The six motion_planners* packages lose their hand-kept __all__. from … import * now exports every public name of the extension. The OMPL list had named only the legacy aliases, so a star import gave OMPLRealVectorPlanProfile but not OMPLRealVectorMoveProfile.

ompl_base removed

tesseract_robotics.ompl_base wrapped five OMPL headers directly and nothing in the package used it. The module, its stub, reeds_shepp_example.py and the tesseract_reeds_shepp_example script are gone. OMPL itself stays: the OMPL planner loads it in C++.

For State, RealVectorBounds, SE2StateSpace, ReedsSheppStateSpace or DubinsStateSpace, use OMPL's own Python bindings.

Time-parameterization factories take no arguments

create_time_optimal_parameterization accepted path_tolerance and min_angle_change, and create_iterative_spline_parameterization accepted add_points, but neither used them: since 0.33 these settings are fields of the composite profiles that compute looks up in the ProfileDictionary, and the algorithm objects the factories return have none. The arguments are gone, so a call that passes one raises TypeError instead of silently doing nothing.

before after
create_time_optimal_parameterization(path_tolerance=0.05) profile = TimeOptimalTrajectoryGenerationCompositeProfile(), profile.path_tolerance = 0.05
create_time_optimal_parameterization(min_angle_change=0.01) profile.min_angle_change = 0.01 on the same profile
create_iterative_spline_parameterization(add_points=False) profile = IterativeSplineParameterizationCompositeProfile(), profile.add_points = False

Add the profile with profiles.addProfile(algorithm.getName(), "DEFAULT", profile).

ChangeCollisionMarginsCommand(pair_margin_data) defaults to MODIFY

The binding defaulted override_type to REPLACE, so leaving it out replaced every pair margin in the environment, where the same C++ call merges the given pairs into the existing ones (#247). Both overloads that take pair_margin_data now default to MODIFY, as upstream. Code that left override_type out and relied on the replace passes it explicitly:

before after
ChangeCollisionMarginsCommand(pairs) ChangeCollisionMarginsCommand(pairs, CollisionMarginPairOverrideType.REPLACE)

CollisionMarginPairOverrideType is in common. The new ChangeCollisionMarginsCommand(default_margin, pairs, override_type) overload defaults to MODIFY too.

The planning API no longer picks a TCP or working frame

tesseract_robotics.planning used to fill in frames it could not know (#30): the TCP as the last of getActiveLinkNames(), which is only the tip for a serial chain, and the working frame as the literal "base_link". get_manipulator_info also cached the guess and returned one shared, mutable ManipulatorInfo per key. Now the caller names every frame: a missing one raises TypeError at the call.

before after
MotionProgram("manipulator") MotionProgram("manipulator", tcp_frame="tool0", working_frame="base_link")
MotionProgram("manipulator", tcp_frame="tool0") MotionProgram("manipulator", tcp_frame="tool0", working_frame="base_link")
robot.get_manipulator_info("manipulator") robot.get_manipulator_info("manipulator", "tool0", "base_link")
robot.fk("manipulator", q) robot.fk("manipulator", q, "tool0")
robot.ik("manipulator", pose, seed=q) robot.ik("manipulator", pose, "tool0", seed=q)
robot.ik("manipulator", pose, q, "tool0") (positional seed, tip_link) robot.ik("manipulator", pose, "tool0", q)
program.to_composite_instruction(joint_names, "tool0") program.to_composite_instruction(joint_names)

For the bundled abb_irb2400 and lbr_iiwa_14_r820 the old guesses were "tool0" and "base_link", so the right-hand column behaves exactly as before. For another robot, pass the link your tool is mounted on and the frame your Cartesian targets are expressed in.

New: MotionProgram and get_manipulator_info take a keyword-only tcp_offset, a named TCP (SRDF group_tcps, #133) or an Isometry3d, and the planner puts tcp_frame * tcp_offset on each Cartesian target. See Frames and the TCP.

PointCloudPoint renamed to PointCloud.Point

The point type of PointCloud is nested in C++ (tesseract::geometry::PointCloud::Point) and is now bound nested (#209). The module-level PointCloudPoint is gone: importing it raises ImportError, reading it as an attribute raises AttributeError. addPoint(x, y, z) is unchanged.

before after
PointCloudPoint(), PointCloudPoint(x, y, z) PointCloud.Point(), PointCloud.Point(x, y, z)
from tesseract_robotics.geometry import PointCloudPoint from tesseract_robotics.geometry import PointCloud, then PointCloud.Point

SWIG-era JointType_* constants removed

scene_graph no longer exports a module constant per JointType value. The seven constants were copies kept from the SWIG bindings; C++ has none of them, and JointType is bound as an enum whose members are the same objects (#214, finishing #176). Importing one now raises ImportError: cannot import name 'JointType_FIXED' from 'tesseract_robotics.scene_graph'; reading one as an attribute raises AttributeError.

before after
JointType_FIXED (also _UNKNOWN, _REVOLUTE, _CONTINUOUS, _PRISMATIC, _FLOATING, _PLANAR) JointType.FIXED (.UNKNOWN, .REVOLUTE, …)
from tesseract_robotics.scene_graph import JointType_FIXED from tesseract_robotics.scene_graph import JointType

Value types compare by value and are unhashable

Every collision, common and environment class whose C++ header declares operator== was bound without it, so == compared identity: ContactRequest() == ContactRequest() was False, and so was env == env.clone(). These classes now bind __eq__/__ne__ from the C++ operators and set __hash__ = None (#169):

module classes
collision ContactResult, ContactResultMap, ContactRequest, ContactManagerConfig, CollisionCheckConfig
common AllowedCollisionMatrix, BytesResource, CollisionMarginData, CollisionMarginPairData, GeneralResourceLocator, JointState, KinematicLimits, KinematicsPluginInfo, ManipulatorInfo, PluginInfo, PluginInfoContainer, SimpleLocatedResource
environment Environment, Command, AddKinematicsInformationCommand, AddLinkCommand, AddSceneGraphCommand, ChangeCollisionMarginsCommand, ChangeJointAccelerationLimitsCommand, ChangeJointOriginCommand, ChangeJointPositionLimitsCommand, ChangeJointVelocityLimitsCommand, ChangeLinkCollisionEnabledCommand, ChangeLinkOriginCommand, ChangeLinkVisibilityCommand, ModifyAllowedCollisionsCommand, MoveJointCommand, MoveLinkCommand, RemoveAllowedCollisionLinkCommand, RemoveJointCommand, RemoveLinkCommand, ReplaceJointCommand

They join the classes that already compared by value (JointTrajectory, the plugin-info structs, AddTrajectoryLinkCommand, AddContactManagersPluginInfoCommand and the two SetActive*ContactManagerCommands).

What breaks is hashing. These objects are mutable, and an object that compares by value must not hash by identity, or two equal objects land in different set buckets. So hash(obj), {obj} and d[obj] = … now raise TypeError: unhashable type. Key on a field that identifies the object, or on id(obj) where identity is what you mean:

before after
seen = {cmd} seen = {(cmd.getType(), cmd.getLinkName())} (whatever names the command)
cache[env] = result cache[env.getName()] = result, or cache[id(env)] (keep env alive)
cmd in history meant identity any(c is cmd for c in history); in now compares values

The equality is the C++ one, unchanged, so it inherits upstream's choices:

  • Floating-point fields compare within a tolerance, not exactly: JointState vectors with isApprox(1e-5) after an exact size check (joint_state.cpp), ContactResult and CollisionCheckConfig with almostEqualRelativeAndAbs, the command origins with isApprox(1e-5).
  • ContactRequest.is_valid compares the validator object: two requests are equal only while they hold the same validator (types.cpp).
  • BytesResource and SimpleLocatedResource compare their parent locators only for presence: ResourceLocator::operator== returns true (resource_locator.cpp).
  • A geometry compares by type and its per-instance uuid (geometry.cpp), so commands holding geometry are equal only when they share it: the same URDF parsed twice gives unequal AddSceneGraphCommands.
  • Environment compares its revisions, the types of its commands, its current state and both timestamps (environment.cpp). env == env.clone() holds, because clone() copies the timestamps (L442–L444); two environments initialised separately from the same URDF are unequal. Its __eq__ releases the GIL, because the C++ operator takes the environment's lock.

Two classes keep identity equality: ResourceLocator and Resource. Their C++ operator== returns true for any pair (L46, L206), so binding it would make every two Python locators equal. A Python locator subclass stays hashable.

KinematicLimits compares the shapes of its four limit matrices before calling the C++ operator, which calls isApprox without checking them and reads out of bounds when they differ (kinematic_limits.cpp). Limits of different shapes are unequal.

createTaskComposerNode and createTaskComposerExecutor raise

Upstream's TaskComposerPluginFactory returns null when it cannot create a node or executor: the name is not configured, the plugin symbol fails to load, or the plugin factory throws. It only logs a console_bridge warning. Python got None, against a stub that promised the object. Both methods now raise TaskComposerPluginError, a RuntimeError (#203). For a name that is not configured, the message lists the configured names.

before after
node = factory.createTaskComposerNode(name)
if node is None: …
try: node = factory.createTaskComposerNode(name)
except TaskComposerPluginError: …
executor = factory.createTaskComposerExecutor(name)
if executor is None: …
try: executor = factory.createTaskComposerExecutor(name)
except TaskComposerPluginError: …

TaskComposer.plan raises UnknownPipelineError for an unknown pipeline; only a planner that ran and found no solution returns a failed PlanningResult.

Pre-0.33 collision-margin aliases removed

tesseract 0.33 renamed the collision-margin members; the bindings kept the old names as aliases of the new ones. The eight aliases are gone (#177); each replacement takes the same arguments and does the same thing.

before after
config.margin_data_override_type config.pair_margin_override_type
manager.setDefaultCollisionMarginData(m) manager.setDefaultCollisionMargin(m)
manager.setPairCollisionMarginData(a, b, m) manager.setCollisionMarginPair(a, b, m)
CollisionMarginOverrideType CollisionMarginPairOverrideType
margins.getPairCollisionMargin(a, b) margins.getCollisionMargin(a, b)
margins.setPairCollisionMargin(a, b, m) margins.setCollisionMargin(a, b, m)

manager is a DiscreteContactManager or ContinuousContactManager, config a ContactManagerConfig, margins a CollisionMarginData. A ContactManagerConfig has no margin_data member (the collision API page used one; that snippet never ran): set its default_margin, pair_margin_data and pair_margin_override_type, then pass it to manager.applyContactManagerConfig(config).

SWIG-era enum constants removed

collision, environment and common no longer export a module constant per enum value. The 14 constants were copies kept from the SWIG bindings; C++ has none of them, and every enum is bound as a class whose members are the same objects (#176). Importing one now raises ImportError: cannot import name 'ContactTestType_ALL' from 'tesseract_robotics.collision'; reading one as an attribute raises AttributeError.

before after
ContactTestType_ALL (also _FIRST, _CLOSEST, _LIMITED) ContactTestType.ALL (.FIRST, .CLOSEST, .LIMITED)
Events_COMMAND_APPLIED, Events_SCENE_STATE_CHANGED Events.COMMAND_APPLIED, Events.SCENE_STATE_CHANGED
ModifyAllowedCollisionsType_ADD (also _REMOVE, _REPLACE) ModifyAllowedCollisionsType.ADD (.REMOVE, .REPLACE)
CONSOLE_BRIDGE_LOG_DEBUG (also _INFO, _WARN, _ERROR, _NONE) LogLevel.debug (.info, .warn, .err, .off): spdlog's levels, see logging
Python
# before
from tesseract_robotics.collision import ContactRequest, ContactTestType_ALL
from tesseract_robotics.common import CONSOLE_BRIDGE_LOG_WARN, setLogLevel

request = ContactRequest(ContactTestType_ALL)
setLogLevel(CONSOLE_BRIDGE_LOG_WARN)
Python
# after
from tesseract_robotics.collision import ContactRequest, ContactTestType
from tesseract_robotics.common import LogLevel, getLogger

request = ContactRequest(ContactTestType.ALL)
getLogger().set_level(LogLevel.warn)

The module-level CONSOLE_BRIDGE_LOG_* copies went in 0.35.0.x; 0.36 then removed console_bridge's LogLevel itself, so the enum is spdlog's and the level is set on the logger.

AnyPoly helpers only in task_composer

environment re-exported AnyPoly_wrap_EnvironmentConst, and command_language re-exported AnyPoly_wrap_CompositeInstruction, AnyPoly_wrap_ProfileDictionary and AnyPoly_as_CompositeInstruction, from task_composer inside a try: … except ImportError: pass. An install whose task-composer extension failed to load lost the names without an error, and importing either package loaded the task composer. The re-exports and command_language._HAS_TASK_COMPOSER are removed (#192); the functions are defined in, and imported from, task_composer. Code that imports them from the old place now fails with ImportError: cannot import name ….

before after
from tesseract_robotics.environment import AnyPoly_wrap_EnvironmentConst from tesseract_robotics.task_composer import AnyPoly_wrap_EnvironmentConst
from tesseract_robotics.command_language import AnyPoly_wrap_CompositeInstruction (also AnyPoly_wrap_ProfileDictionary, AnyPoly_as_CompositeInstruction) from tesseract_robotics.task_composer import AnyPoly_wrap_CompositeInstruction (…)

A str is content, pathlib.Path is a file

common.FilesystemPath was a str subclass, so Environment.init had to guess whether a string was a path or URDF content, and init(str, str, locator) loaded files where the C++ std::string overload parses content. std::filesystem::path now converts with nanobind's caster (str | os.PathLike in, pathlib.Path out), and Environment.init binds the four native overloads (#165):

call meaning
init(urdf_xml, locator), init(urdf_xml, srdf_xml, locator) parse URDF/SRDF content
init(Path(urdf), locator), init(Path(urdf), Path(srdf), locator) load files
init(str(urdf_path), …) parsed as XML: returns False
init(urdf_xml, Path(srdf), locator) (either order) TypeError

The path overloads of Environment.init and the ContactManagersPluginFactory / KinematicsPluginFactory config constructors accept os.PathLike only, never str, because each sits beside a str content overload. Every other std::filesystem::path parameter takes str | os.PathLike.

before after
env.init(FilesystemPath(u), FilesystemPath(s), loc) env.init(Path(u), Path(s), loc)
env.init(path_str, loc) (path) env.init(Path(path_str), loc)
env.initFromUrdf(xml, loc) env.init(xml, loc)
env.initFromUrdfSrdf(u_xml, s_xml, loc) env.init(u_xml, s_xml, loc)
KinematicsPluginFactory(_FilesystemPath(p), loc) (also ContactManagersPluginFactory) KinematicsPluginFactory(Path(p), loc)
TaskComposerPluginFactory(FilesystemPath(p), loc) TaskComposerPluginFactory(str(p), loc)
TransformMap() {}

TaskComposerPluginFactory kept its config path as str in this release; the next one binds its path/content pair the same way (#337).

The convex evaluators take the QP solution vector

QPProblem.evaluateConvexCosts, evaluateTotalConvexCost and evaluateConvexConstraintViolations read var_vals in the layout of the QP that the last convexify() built: getNumQPVars() entries, the NLP variables followed by the slack variables (L28). trajopt documents that size (L59, L67) but does not check it. The binding now raises QPSolutionSizeError for any other size, and NotConvexifiedError before the first convexify(), while getNumQPVars() is still 0 (L99, L831). Both are ValueErrors:

Text Only
QPSolutionSizeError: evaluateConvexCosts: var_vals has 3 entries; it must be the QP solution vector of getNumQPVars() = 5 entries, the NLP variables followed by the slack variables
NotConvexifiedError: evaluateConvexCosts: the problem has no convex model yet; call convexify() first

What used to work and now raises: an NLP-sized var_vals on a problem with constraint sets and no hinge or absolute cost. Each constraint row adds one or two slack variables, and trajopt 0.35.0, which 0.35.0.8 and earlier bundle, reads only the NLP block there, so the call returned the right values. Append zeros for the slack variables:

Python
import numpy as np

x = np.zeros(problem.getNumNLPVars())          # an NLP-sized point
problem.convexify()
n_slack = problem.getNumQPVars() - problem.getNumNLPVars()
model_costs = problem.evaluateConvexCosts(np.concatenate([x, np.zeros(n_slack)]))

A QP solution, such as SQPResults.new_var_vals in a callback, already has the right size. SQPResults.best_var_vals needs it too: on trajopt 0.35.0 it is NLP-sized until the first accepted step and QP-sized after it (always NLP-sized in a wheel built on a trajopt that contains trajopt#592), so take its first getNumNLPVars() entries and pad them as above. A problem with no constraint sets and only squared costs has no slack variables, so its NLP point is a QP point and nothing changes.

Why the binding checks: with a hinge or absolute cost, trajopt 0.35.0 multiplies the cost's full QP rows, slack columns included, into var_vals (L187–L188), so an NLP-sized vector was read past its end. On a one-joint problem whose absolute cost is 0.5, a view of the first three entries of a longer buffer read 3.5 or 0.5, depending on the two entries after the view, and a fresh three-entry array read 14.6. Before the first convexify(), an empty or NLP-sized vector segfaulted on a squared cost. The rule covers all three evaluators, although trajopt 0.35.0 reads only the NLP block in two of them: one contract, the one trajopt documents for all three once trajopt#592 is in.

IfoptQPProblem and IfoptProblem removed

tesseract_robotics.trajopt_sqp no longer binds IfoptQPProblem or IfoptProblem. trajopt is removing IfoptQPProblem (trajopt#595), and IfoptProblem was bound only to construct it. Code that uses either now fails with AttributeError: module 'tesseract_robotics.trajopt_sqp' has no attribute 'IfoptQPProblem' (or 'IfoptProblem'). Build a TrajOptQPProblem over the same variables, and add every set to it, each cost with a penalty type (#148):

Python
# before
nlp = tsqp.IfoptProblem(nodes_variables)
nlp.addConstraintSet(joint_constraint)
nlp.addCostSet(vel_cost)                        # no penalty type
problem = tsqp.IfoptQPProblem(nlp)
problem.addConstraintSet(collision_constraint)
problem.setup()
Python
# after
from tesseract_robotics import trajopt_sqp as tsqp

problem = tsqp.TrajOptQPProblem(nodes_variables)
problem.addConstraintSet(joint_constraint)
problem.addConstraintSet(collision_constraint)
problem.addCostSet(vel_cost, tsqp.CostPenaltyType.SQUARED)
problem.setup()

It is not a rename. IfoptQPProblem as 0.35.0.8 and earlier bind it, on trajopt 0.35.0, and TrajOptQPProblem on the pinned trajopt a504b22 differ in five ways, and the third and fourth change results:

IfoptQPProblem (removed) TrajOptQPProblem
1. Per set, not per row One merit coefficient, name and violation per constraint row; names are <set>_<row> (L93, L100). One per constraint set (L738–L760, L833–L835, L1163–L1186). Code that indexes names, violations or merit coefficients by row breaks, and the solver inflates a whole set's merit coefficient at once.
2. addCostSet checks bounds Checks nothing; rejects HINGE (L50–L78). Every row must be an equality or one-sided, with any penalty type; a range row raises, from addConstraintSet too (L115–L127).
3. No raw-cost path A cost added with IfoptProblem.addCostSet bypasses IfoptQPProblem::addCostSet (L59): it gets no gradient and no Hessian in the QP (L190, L263), while the merit still reads its raw, signed rows (L525–L531). Every cost goes in with addCostSet(set, penalty_type). A cost that was inert now shapes the steps.
4. The merit matches the model Weights the model but not the merit, and counts the model once per cost term, so the solver can reject every step and stop at the seed (trajopt#595). The merit weights and counts every cost as the model does (L1118–L1162), and weighs each constraint set's violation by its coefficients, as the QP prices its slack (L887–L903), so steps the old ratio rejected can be accepted. An ABSOLUTE or HINGE cost is modelled on its linearized rows, without the slacks (L233–L295; trajopt#592), so a violation larger than the trust box is reduced step by step (the QP problem).
5. Dynamic sets Throws on isDynamic() sets (L42–L48). Accepts them (L488–L540).

How much the third difference moves a result: this package's online SQP example added its velocity cost with IfoptProblem.addCostSet, so its QP had no cost term and OSQP solved with an empty Hessian. As a squared cost on TrajOptQPProblem, the global solve's summed squared joint steps fell from 23.2 to 3.9, against 3.6 for the straight-line seed, and getTotalExactCost() now reports that sum instead of the first velocity row (0.5).

Evidence

The five differences are read from the sources linked above: trajopt 0.35.0 for IfoptQPProblem, the pinned trajopt a504b22 for TrajOptQPProblem. The example's numbers are measured on this repository's online_planning_sqp_example.py, and tests/examples/test_online_planning_sqp_example.py pins its problem class, its cost as the squared joint steps, and a global solve that reaches the target from the pinned start. How much results move in other code depends on its costs; nothing here measures that. The ABSOLUTE/HINGE model is also measured: TestTrajOptQPProblemPenaltyCosts in tests/trajopt_sqp/test_trajopt_sqp_bindings.py pins it.

Quaterniond takes xyzw only

The four-scalar constructor was scalar-first (w, x, y, z), the opposite of every other quaternion surface in the package. It is gone; Quaterniond(w, x, y, z) raises TypeError.

before after
Quaterniond(w, x, y, z) Quaterniond.from_xyzw(x, y, z, w) or Quaterniond([x, y, z, w])
Quaterniond(coeffs=[x, y, z, w]) Quaterniond(xyzw=[x, y, z, w])

Environment events and keywords

EventCallbackFn wrapped a callable only to hand it to addEventCallback. The method takes the callable and returns the key.

before after
env.addEventCallback(key, EventCallbackFn(fn)) key = env.addEventCallback(fn)
env.removeEventCallback(hash=key) env.removeEventCallback(key)
env.getJointGroup(name=..., joint_ids=...) env.getJointGroup(group_name=..., joint_ids=...)

Overload copies removed from Environment, StateSolver and kinematics

Each removed name duplicated a native overload under another name.

before after
Environment.getStateByMap, getStateByNamesAndValues Environment.getState
Environment.setStateByNamesAndValues Environment.setState(joint_ids, joint_values)
Environment.getCurrentJointValuesByNames Environment.getCurrentJointValues(joint_ids)
StateSolver.setStateByMap, setStateByNamesAndValues StateSolver.setState
JointGroup.calcJacobianWithPoint(q, link, p) JointGroup.calcJacobian(q, link, p)
KinematicGroup.calcInvKinMultiple(list, seed) KinematicGroup.calcInvKin(list, seed)

VectorVector3d and VectorIsometry3d removed

before after
common.VectorVector3d([...]) [np.array(...), ...]
common.VectorIsometry3d([...]) [Isometry3d(...), ...]

Functions that returned these containers return lists.

Environment and Poly lookups raise, and casts are views

before after
Environment.getLink / getJoint of a missing id: RuntimeError KeyError
getJointGroup / getKinematicGroup / getGroupJointIds / getLinkTransform, contact managers by name, unknown id: RuntimeError KeyError
getLink / getJoint returned a reference that dangled after a removal the shared Link / Joint, valid after a removal
ip.asMoveInstruction() returned a copy a view: edits write through; copy.copy(...) copies
a wrong as*() cast raised RuntimeError PolyTypeError (a TypeError), also for the WaypointPoly casts
20 per-type applyCommand overloads applyCommand(command), one overload
CompositeInstruction.push_back / insert / del / clear while Python holds an element InstructionHeldError; drop the reference first

Geometry inputs are validated

before after
Isometry3d(matrix) accepted any 4x4 NotRotationError unless the upper 3x3 is a rotation; the same for the rotation inputs of AngleAxisd
a zero quaternion or axis DegenerateRotationError; a non-unit one is normalized
Hyperplane3d.Through(p0, p1, p2): normal (p1 - p0) x (p2 - p0) normal (p2 - p0) x (p1 - p0), as Eigen; swap p1 and p2 for the old plane
Hyperplane3d / ParametrizedLine3d degenerate: ValueError for small inputs DegenerateGeometryError (a ValueError), only for exactly-zero vectors

Serialization and URDF writes raise, and bytes are bytes

Python
# 0.35
ok = serialization.environment_to_file(env, "env.xml")   # False on failure
blob = serialization.environment_to_binary(env)          # list[int]
urdf.writeURDFFile(env, package_path, "robot")           # None, failures silent
Python
# 0.36
from pathlib import Path

from tesseract_robotics import serialization, urdf

serialization.environment_to_file(env, Path("env.xml"))  # None; OSError on failure
blob = serialization.environment_to_binary(env)          # bytes
path = urdf.writeURDFFile(scene_graph, str(package_path), "robot")  # package_path/urdf/robot.urdf

Files are written and read exactly at path (str or os.PathLike, no suffix appended). writeURDFFile raises URDFWriteError with the nested cause; urdf_name is a stem.

Named errors in the bindings

before after
a plugin-factory config path the locator cannot resolve: a crash FileNotFoundError (ContactManagersPluginFactory, KinematicsPluginFactory, TaskComposerPluginFactory, TaskComposerServer.loadConfig)
CartAxis constraint with a zero axis: RuntimeError DegenerateAxisError (a ValueError)
python_constraints: bare ValueError BoundsShapeError, InvertedBoundsError, ClearanceMarginError
a Descartes Python profile whose create* returns the wrong type: AttributeError on a worker ProfileReturnTypeError (a TypeError) at creation
ContactResultVector[-1] works
ContactResultMap.filter passed a reference passes a copy, copied back into the map
OSQPEigenSolver without setAdaptiveRhoInterval or getters both OSQP classes have set* / get* for every setting
tesseract_robotics/trajopt_ifopt.pyi, a flat module the package tesseract_robotics.trajopt_ifopt; imports are unchanged

The planning API raises instead of returning flags

Python
# 0.35
q = robot.ik("tool0", pose)
if q is None:
    ...
if not robot.add_link(link, joint):
    ...
Python
# 0.36
from tesseract_robotics.planning.errors import IKNoSolutionError

try:
    q = robot.ik("manipulator", pose, "tool0")  # ndarray
except IKNoSolutionError:
    ...
robot.add_link(link, joint)               # None; EnvironmentCommandError on refusal

remove_link, move_link, add_allowed_collision, set_collision_margin and create_obstacle behave like add_link. Planning failures are named exceptions in tesseract_robotics.planning.errors, each a subclass of the builtin it replaces. Robot.build(env) validates the environment and RobotState checks its name and position counts.

Planning names removed or renamed

before after
MotionProgram.start_at(...) add_target(...)
create_descartes_pipeline_profiles create_descartes_default_profiles
CartesianTarget(position=p, quaternion=q) CartesianTarget.from_xyz_quat(p, q); CartesianTarget(pose)
TRAJOPT_PROFILE_NAMES STANDARD_PROFILE_NAMES
planning.profiles._create_trajopt_profiles planning.profiles.create_trajopt_profile_pair (returns composite, move)
TaskComposer(config_path=...) removed; the config comes from get_task_composer_config_path()

planning.profiles is a package (trajopt, ompl, descartes, time_param, pipelines, names); STANDARD_PROFILE_NAMES and the other name lists are tuples. num_threads is not capped to the core count and must be at least 1.

TaskComposer.plan raises, and plan_ompl uses FreespacePipeline

before after
an unknown pipeline, a malformed program or a missing pipeline port: successful=False UnknownPipelineError or the matching named error; successful=False only when a planner ran and found no solution
a pipeline outside the default-profile table planned with an empty dictionary NoDefaultProfilesError
plan_ompl(...) ran OMPLPipeline runs FreespacePipeline; pass pipeline="OMPLPipeline" for raw OMPL
warmup(["Bad"]) skipped a pipeline that did not load PipelineWarmupError
plan seeded the caller's CompositeInstruction in place seeds a copy
a target without a profile defaulted to DEFAULT over MotionProgram(profile=...) inherits the program's profile

Package surface

before after
get_tesseract_resource_path() fell back to an environment's share/ the support distribution only; SupportDataNotFoundError otherwise
__version__ fell back to a placeholder the installed distribution's version
from tesseract_robotics.scene_graph import * included SceneState from tesseract_robotics.scene_graph import SceneState
planning, common, scene_graph defined __all__ no __all__; import * exports every public name
trajectory points always carried time time only where a time parameterization set velocities
mesh_from_file on a missing file ResourceNotFoundError; AmbiguousMeshError for several meshes

Examples raise PlanningFailedError

The examples' main() returned a failed result after printing. They raise PlanningFailedError, and online_planning_sqp_example raises when the initial solve does not converge or a replanning QP step fails. Catch the error where you called run() or main().

Emitters take frames from the ManipulatorInfo

Each move now carries its working frame, TCP frame and TCP offset from its ManipulatorInfo. Every dialect resolves them through a required frame binding and raises UnboundFrameError for a frame it does not know.

before after
emit_krl(program) emit_krl(program, frames=krl_frames(...))
emit_ls(program) emit_ls(program, frames=ls_frames(...), config=resolver)
emit_jbi(program), JbiProfile(tool=...) emit_jbi(program, frames=jbi_frames(...), calibration=JbiPulseCalibration(...)); no tool field
emit_urscript(program) emit_urscript(program, frames=ur_frames(...))
emit_rapid(program, profiles) returned a str; fixed [1, 0, 0, 0] confdata returns an EmittedProgram; frames=rapid_frames(...), posture=OpwPostureSolver(...); cf1/cf4/cf6 from the seed joints
JBI joint degrees under ///POSTYPE PULSE integer encoder pulses from the calibration; a Cartesian move raises
SetToolInstruction emitted a tool command UnsupportedInstructionError in every dialect
names rewritten to fit the dialect IdentifierError
more than six joint values: extra axes dropped ExternalAxisError on KRL, LS, JBI and URScript
KRL FREESPACE Cartesian move MissingConfigurationError (a PTP to a frame needs Status and Turn)
RapidEmitterError, Config.neutral_for, rapid.utils, core.naming.safe_identifier, jbi.backend.MissingSeedError, UnknownKinematicTopologyError, ExternalAxisUnitError removed; the errors are named per failure mode (InvalidProfileError, InvalidLayoutError, InvalidDeclarationError, ProgramStructureError, ...)
Trajectory.from_composite(program) of an untimed program UntimedTrajectoryError unless untimed_step_s= is given (also TesseractViewer.update_trajectory)

The RAPID DSL declares typed objects with a .name (Robtarget, Jointtarget, Tooldata, Workobject, Speed, Zone, Pos, RapidBool); Tooldata and Workobject take Poses in metres, Speed and Zone take SI values, and statements run inside with RapidWriter() as w:.

0.35.0.1

Transform removed; Pose is an Isometry3d

tesseract_robotics.planning.Pose now subclasses Isometry3d. Its rotation math runs in Eigen, its numpy-property facade is gone, its stored data are properties, and its factories collapse to one name each that accepts both scalar-positional and array-like arguments. The Transform alias is removed: use Pose (#76).

Resource URIs moved

tesseract 0.35 folds its support data into the tesseract package, so package://tesseract_support/... is now package://tesseract/support/... in every URDF, SRDF and locateResource call. The rest of that upgrade leaves the Python API unchanged; see the 0.34 → 0.35 guide.

0.34.1.0

The tesseract 0.34 upgrade removed the ifopt module (its types moved to trajopt_ifopt) and replaced JointPosition with Var / Node / NodesVariables. It also removed CartPosInfo and CollisionCache, dropped getStaticKey() from profiles, and renamed the cost and constraint evaluation methods. The 0.33 → 0.34 guide has each change with its replacement.