Remove deprecated code 2022-05 (#17076)

bindings/pydrake/multibody/BUILD.bazel

@@ -122,14 +122,12 @@ drake_pybind_library(
         "//bindings/pydrake:geometry_py",
         "//bindings/pydrake/common:cpp_template_py",
     ],
-    py_srcs = ["_plant_extra.py"],
 )
 
 drake_pybind_library(
     name = "parsing_py",
     cc_deps = [
         "//bindings/pydrake:documentation_pybind",
-        "//bindings/pydrake/common:deprecation_pybind",
     ],
     cc_srcs = ["parsing_py.cc"],
     package_info = PACKAGE_INFO,
@@ -267,7 +265,6 @@ drake_py_unittest(
     deps = [
         ":parsing_py",
         ":plant_py",
-        "//bindings/pydrake/common/test_utilities",
     ],
 )
 
@@ -286,13 +283,10 @@ drake_py_unittest(
         ":parsing_py",
         ":plant_py",
         ":tree_py",
-        "//bindings/pydrake/common/test_utilities:deprecation_py",
         "//bindings/pydrake/common/test_utilities:numpy_compare_py",
         "//bindings/pydrake/common/test_utilities:pickle_compare_py",
         "//bindings/pydrake/systems:analysis_py",
         "//bindings/pydrake/systems:scalar_conversion_py",
-        # TODO(jwnimmer-tri) Remove this on 2022-05-01 per deprecations.
-        ":meshcat_py",
     ],
 )
 

bindings/pydrake/multibody/parsing_py.cc

@@ -1,7 +1,6 @@
 #include "pybind11/pybind11.h"
 #include "pybind11/stl.h"
 
-#include "drake/bindings/pydrake/common/deprecation_pybind.h"
 #include "drake/bindings/pydrake/documentation_pybind.h"
 #include "drake/bindings/pydrake/pydrake_pybind.h"
 #include "drake/multibody/parsing/package_map.h"
@@ -57,13 +56,6 @@ PYBIND11_MODULE(parsing, m) {
             py::arg("environment_variable"),
             cls_doc.PopulateFromEnvironment.doc)
         .def_static("MakeEmpty", &Class::MakeEmpty, cls_doc.MakeEmpty.doc);
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-    cls.def("PopulateUpstreamToDrake",
-        WrapDeprecated(cls_doc.PopulateUpstreamToDrake.doc_deprecated,
-            &Class::PopulateUpstreamToDrake),
-        py::arg("model_file"), cls_doc.PopulateUpstreamToDrake.doc_deprecated);
-#pragma GCC diagnostic pop
   }
 
   // Parser

bindings/pydrake/multibody/plant_py.cc

@@ -1283,8 +1283,6 @@ PYBIND11_MODULE(plant, m) {
 
   type_visit([m](auto dummy) { DoScalarDependentDefinitions(m, dummy); },
       CommonScalarPack{});
-
-  ExecuteExtraPythonCode(m);
 }  // NOLINT(readability/fn_size)
 
 }  // namespace pydrake

bindings/pydrake/multibody/test/parsing_test.py

@@ -15,7 +15,6 @@
 import unittest
 
 from pydrake.common import FindResourceOrThrow
-from pydrake.common.test_utilities.deprecation import catch_drake_warnings
 from pydrake.multibody.tree import (
     ModelInstanceIndex,
 )
@@ -51,11 +50,6 @@ def test_package_map(self):
         dut2.Remove(package_name="root")
         self.assertEqual(dut2.size(), 0)
 
-        # Simple coverage test for Drake paths.
-        with catch_drake_warnings(expected_count=1):
-            dut.PopulateUpstreamToDrake(model_file=model)
-        self.assertGreater(dut.size(), 1)
-
         # Simple coverage test for folder and environment.
         dut.PopulateFromEnvironment(environment_variable='TEST_TMPDIR')
         dut.PopulateFromFolder(path=tmpdir)

bindings/pydrake/multibody/test/plant_test.py

@@ -61,9 +61,6 @@
     ContactModel,
     ContactResults_,
     ContactResultsToLcmSystem,
-    ContactResultsToMeshcatParams,
-    ContactResultsToMeshcat,
-    ContactResultsToMeshcat_,
     CoulombFriction_,
     ExternallyAppliedSpatialForce_,
     MultibodyPlant,
@@ -83,7 +80,6 @@
 from pydrake.common import FindResourceOrThrow
 from pydrake.common.deprecation import install_numpy_warning_filters
 from pydrake.common.test_utilities import numpy_compare
-from pydrake.common.test_utilities.deprecation import catch_drake_warnings
 from pydrake.common.test_utilities.pickle_compare import assert_pickle
 from pydrake.common.value import AbstractValue, Value
 from pydrake.geometry import (
@@ -2301,39 +2297,6 @@ def _sanity_check_contact_surface(self, dut):
         dut.Equal(surface=dut)
         copy.copy(dut)
 
-    def test_deprecated_contact_results_to_meshcat_default_scalar(self):
-        """Checks ContactResultsToMeshcat for deprecation."""
-        meshcat = Meshcat()
-        with catch_drake_warnings(expected_count=1):
-            params = ContactResultsToMeshcatParams()
-        self.assertIsNotNone(params)
-        with catch_drake_warnings(expected_count=1):
-            vis = ContactResultsToMeshcat(meshcat=meshcat, params=params)
-        vis.Delete()
-        builder = DiagramBuilder_[float]()
-        plant, scene_graph = AddMultibodyPlantSceneGraph(builder, 0.01)
-        plant.Finalize()
-        with catch_drake_warnings(expected_count=1):
-            ContactResultsToMeshcat.AddToBuilder(
-                builder=builder, plant=plant, meshcat=meshcat, params=params)
-
-    @numpy_compare.check_nonsymbolic_types
-    def test_deprecated_contact_results_to_meshcat_specific_scalar(self, T):
-        """Checks ContactResultsToMeshcat_[T] for deprecation."""
-        meshcat = Meshcat()
-        with catch_drake_warnings(expected_count=1):
-            params = ContactResultsToMeshcatParams()
-        self.assertIsNotNone(params)
-        with catch_drake_warnings(expected_count=1):
-            vis = ContactResultsToMeshcat_[T](meshcat=meshcat, params=params)
-        vis.Delete()
-        builder = DiagramBuilder_[T]()
-        plant, scene_graph = AddMultibodyPlantSceneGraph(builder, 0.01)
-        plant.Finalize()
-        with catch_drake_warnings(expected_count=1):
-            ContactResultsToMeshcat_[T].AddToBuilder(
-                builder=builder, plant=plant, meshcat=meshcat, params=params)
-
     def test_free_base_bodies(self):
         plant = MultibodyPlant_[float](time_step=0.01)
         model_instance = plant.AddModelInstance("new instance")

bindings/pydrake/solvers/mathematicalprogram_py.cc

@@ -1502,60 +1502,6 @@ for every column of ``prog_var_vals``. )""")
       .def("RemoveConstraint", &MathematicalProgram::RemoveConstraint,
           py::arg("constraint"), doc.MathematicalProgram.RemoveConstraint.doc);
 
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-  prog_cls
-      .def("NewNonnegativePolynomial",
-          WrapDeprecated(
-              doc.MathematicalProgram.NewNonnegativePolynomial
-                  .doc_deprecated_deprecated_2args_monomial_basis_type,
-              static_cast<std::pair<Polynomial, MatrixXDecisionVariable> (
-                  MathematicalProgram::*)(
-                  const Eigen::Ref<const VectorX<symbolic::Monomial>>&,
-                  MathematicalProgram::NonnegativePolynomial)>(
-                  &MathematicalProgram::NewNonnegativePolynomial)),
-          py::arg("monomial_basis"), py::arg("type"),
-          doc.MathematicalProgram.NewNonnegativePolynomial
-              .doc_deprecated_deprecated_2args_monomial_basis_type)
-      .def("NewNonnegativePolynomial",
-          WrapDeprecated(
-              doc.MathematicalProgram.NewNonnegativePolynomial
-                  .doc_deprecated_deprecated_3args_gramian_monomial_basis_type,
-              static_cast<symbolic::Polynomial (MathematicalProgram::*)(
-                  const Eigen::Ref<const MatrixX<symbolic::Variable>>&,
-                  const Eigen::Ref<const VectorX<symbolic::Monomial>>&,
-                  MathematicalProgram::NonnegativePolynomial)>(
-                  &MathematicalProgram::NewNonnegativePolynomial)),
-          py::arg("gramian"), py::arg("monomial_basis"), py::arg("type"),
-          doc.MathematicalProgram.NewNonnegativePolynomial
-              .doc_deprecated_deprecated_3args_gramian_monomial_basis_type)
-      .def("NewNonnegativePolynomial",
-          WrapDeprecated(
-              doc.MathematicalProgram.NewNonnegativePolynomial
-                  .doc_deprecated_deprecated_3args_indeterminates_degree_type,
-              static_cast<
-                  std::pair<symbolic::Polynomial, MatrixXDecisionVariable> (
-                      MathematicalProgram::*)(const symbolic::Variables&,
-                      int degree, MathematicalProgram::NonnegativePolynomial)>(
-                  &MathematicalProgram::NewNonnegativePolynomial)),
-          py::arg("indeterminates"), py::arg("degree"), py::arg("type"),
-          doc.MathematicalProgram.NewNonnegativePolynomial
-              .doc_deprecated_deprecated_3args_indeterminates_degree_type)
-      .def("AddMaximizeLogDeterminantSymmetricMatrixCost",
-          WrapDeprecated(
-              doc.MathematicalProgram
-                  .AddMaximizeLogDeterminantSymmetricMatrixCost.doc_deprecated,
-              static_cast<std::tuple<Binding<LinearCost>,
-                  VectorX<symbolic::Variable>, MatrixX<symbolic::Expression>> (
-                  MathematicalProgram::*)(
-                  const Eigen::Ref<const MatrixX<symbolic::Expression>>& X)>(
-                  &MathematicalProgram::
-                      AddMaximizeLogDeterminantSymmetricMatrixCost)),
-          py::arg("X"),
-          doc.MathematicalProgram.AddMaximizeLogDeterminantSymmetricMatrixCost
-              .doc_deprecated);
-#pragma GCC diagnostic pop
-
   py::enum_<SolutionResult> solution_result_enum(
       m, "SolutionResult", doc.SolutionResult.doc);
   solution_result_enum
@@ -2048,21 +1994,7 @@ void BindFreeFunctions(py::module m) {
               const std::optional<SolverOptions>&>(&solvers::Solve),
           py::arg("prog"), py::arg("initial_guess") = py::none(),
           py::arg("solver_options") = py::none(), doc.Solve.doc_3args)
-      .def("GetProgramType", &solvers::GetProgramType, doc.GetProgramType.doc)
-      // The following Solve() methods are placed here to be in the
-      // mathematicalprogram module, so as not to provide a conflicting Solve
-      // method in the trajectory optimization module.
-      .def(
-          "Solve",
-          [](const systems::trajectory_optimization::MultipleShooting&
-                  trajopt) {
-            WarnDeprecated(
-                "The trajectory optimization classes no longer derive from "
-                "MathematicalProgram.  Use Solve(trajopt.prog()).",
-                "2022-05-01");
-            return Solve(trajopt.prog());
-          },
-          py::arg("trajopt"), "This method calls Solve(trajopt.prog()).");
+      .def("GetProgramType", &solvers::GetProgramType, doc.GetProgramType.doc);
 }
 
 PYBIND11_MODULE(mathematicalprogram, m) {

bindings/pydrake/solvers/test/mathematicalprogram_test.py

@@ -1,7 +1,19 @@
 from pydrake.solvers import mathematicalprogram as mp
 
+import copy
+from functools import partial
+import unittest
+import warnings
+
+import numpy as np
+import scipy.sparse
+
+from pydrake.autodiffutils import AutoDiffXd
+from pydrake.common import kDrakeAssertIsArmed
+from pydrake.common.test_utilities import numpy_compare
 from pydrake.common.test_utilities.deprecation import catch_drake_warnings
-import pydrake.solvers.mathematicalprogram._testing as mp_testing
+from pydrake.forwarddiff import jacobian
+from pydrake.math import ge
 from pydrake.solvers.gurobi import GurobiSolver
 from pydrake.solvers.snopt import SnoptSolver
 from pydrake.solvers.scs import ScsSolver
@@ -15,22 +27,7 @@
     SolverId,
     SolverInterface
     )
-
-import copy
-from functools import partial
-import unittest
-import warnings
-
-import numpy as np
-import scipy.sparse
-
-import pydrake
-from pydrake.common import kDrakeAssertIsArmed
-from pydrake.autodiffutils import AutoDiffXd
-from pydrake.common.test_utilities import numpy_compare
-from pydrake.common.test_utilities.deprecation import catch_drake_warnings
-from pydrake.forwarddiff import jacobian
-from pydrake.math import ge
+import pydrake.solvers.mathematicalprogram._testing as mp_testing
 import pydrake.symbolic as sym
 
 
@@ -663,32 +660,6 @@ def test_sos_polynomial(self):
         self.assertIsInstance(poly3, sym.Polynomial)
         self.assertIsInstance(gramian3, np.ndarray)
 
-    def test_nonnegative_polynomial(self):
-        # Only check if the API works.
-        prog = mp.MathematicalProgram()
-        x = prog.NewIndeterminates(3, "x")
-        with catch_drake_warnings(expected_count=1):
-            (poly1, gramian1) = prog.NewNonnegativePolynomial(
-                indeterminates=sym.Variables(x), degree=4,
-                type=mp.MathematicalProgram.NonnegativePolynomial.kSdsos)
-        self.assertIsInstance(poly1, sym.Polynomial)
-        self.assertIsInstance(gramian1, np.ndarray)
-
-        gramian2 = prog.NewSymmetricContinuousVariables(2)
-        with catch_drake_warnings(expected_count=1):
-            poly2 = prog.NewNonnegativePolynomial(
-                gramian=gramian2,
-                monomial_basis=(sym.Monomial(x[0]), sym.Monomial(x[1])),
-                type=mp.MathematicalProgram.NonnegativePolynomial.kDsos)
-        self.assertIsInstance(gramian2, np.ndarray)
-
-        with catch_drake_warnings(expected_count=1):
-            poly3, gramian3 = prog.NewNonnegativePolynomial(
-                monomial_basis=(sym.Monomial(x[0]), sym.Monomial(x[1])),
-                type=mp.MathematicalProgram.NonnegativePolynomial.kSos)
-        self.assertIsInstance(poly3, sym.Polynomial)
-        self.assertIsInstance(gramian3, np.ndarray)
-
     def test_new_even_degree_nonnegative_polynomial(self):
         prog = mp.MathematicalProgram()
         x = prog.NewIndeterminates(3, "x")
@@ -808,22 +779,6 @@ def test_log_determinant(self):
         result = mp.Solve(prog)
         self.assertTrue(result.is_success())
 
-    def test_log_determinant_depreated(self):
-        # Find the minimal ellipsoid that covers some given points.
-        prog = mp.MathematicalProgram()
-        X = prog.NewSymmetricContinuousVariables(2)
-        pts = np.array([[1, 1], [1, -1], [-1, 1]])
-        for i in range(3):
-            pt = pts[i, :]
-            prog.AddLinearConstraint(pt.dot(X.dot(pt)) <= 1)
-        with catch_drake_warnings(expected_count=1):
-            linear_cost, log_det_t, log_det_Z = \
-                prog.AddMaximizeLogDeterminantSymmetricMatrixCost(X=X)
-        self.assertEqual(log_det_t.shape, (2,))
-        self.assertEqual(log_det_Z.shape, (2, 2))
-        result = mp.Solve(prog)
-        self.assertTrue(result.is_success())
-
     def test_maximize_geometric_mean(self):
         # Find the smallest axis-algined ellipsoid that covers some given
         # points.

bindings/pydrake/systems/BUILD.bazel

@@ -191,7 +191,6 @@ drake_pybind_library(
         "//bindings/pydrake/solvers:mathematicalprogram_py",
         "//bindings/pydrake:trajectories_py",
     ],
-    py_srcs = ["_trajectory_optimization_extra.py"],
 )
 
 # TODO(eric.cousineau): Put this under test once `pydot` is in
@@ -630,7 +629,6 @@ drake_py_unittest(
     name = "trajectory_optimization_test",
     deps = [
         ":trajectory_optimization_py",
-        "//bindings/pydrake/common/test_utilities",
         "//bindings/pydrake/examples:pendulum_py",
     ],
 )