Remove deprecated code (#8656)

commandsv2/src/main/python/commands2/__init__.py

@@ -59,16 +59,3 @@ __all__ = [
     "WaitUntilCommand",
     "WrapperCommand",
 ]
-
-if not TYPE_CHECKING:
-
-    def __getattr__(attr):
-        if attr == "SubsystemBase":
-            import warnings
-
-            warnings.warn(
-                "SubsystemBase is deprecated", DeprecationWarning, stacklevel=2
-            )
-            return Subsystem
-
-        raise AttributeError(f"module {__name__!r} has no attribute {attr!r}")

commandsv2/src/main/python/commands2/command.py

@@ -260,35 +260,6 @@ class Command(Sendable):
 
         return SequentialCommandGroup(self, *next)
 
-    def deadlineWith(self, *parallel: Command) -> ParallelDeadlineGroup:
-        """
-        Decorates this command with a set of commands to run parallel to it, ending when the calling
-        command ends and interrupting all the others. Often more convenient/less-verbose than
-        constructing a new ParallelDeadlineGroup explicitly.
-
-        .. note:: This decorator works by adding this command to a composition.
-                  The command the decorator was called on cannot be scheduled
-                  independently or be added to a different composition (namely,
-                  decorators), unless it is manually cleared from the list of composed
-                  commands with :func:`commands2.CommandScheduler.removeComposedCommand`.
-                  The command composition returned from this method can be further
-                  decorated without issue.
-
-        :param parallel: the commands to run in parallel
-        :returns: the decorated command
-        """
-        import warnings
-
-        warnings.warn(
-            "deadlineWith is deprecated use deadlineFor instead",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-
-        from .paralleldeadlinegroup import ParallelDeadlineGroup
-
-        return ParallelDeadlineGroup(self, *parallel)
-
     def deadlineFor(self, *parallel: Command) -> ParallelDeadlineGroup:
         """
         Decorates this command with a set of commands to run parallel to it, ending when the calling

commandsv2/src/main/python/commands2/proxycommand.py

@@ -1,13 +1,9 @@
 # validated: 2024-01-19 DS 192a28af4731 ProxyCommand.java
 from __future__ import annotations
 
-from typing import Callable, overload
-
 from wpiutil import SendableBuilder
 
 from .command import Command
-from .util import format_args_kwargs
-import warnings
 
 
 class ProxyCommand(Command):
@@ -21,26 +17,8 @@ class ProxyCommand(Command):
     If this command is interrupted, it will cancel the command.
     """
 
-    _supplier: Callable[[], Command]
+    _command: Command
 
-    @overload
-    def __init__(self, supplier: Callable[[], Command]):
-        """
-        Creates a new ProxyCommand that schedules the supplied command when initialized, and ends when
-        it is no longer scheduled. Use this for lazily creating **proxied** commands at
-        runtime. Proxying should only be done to escape from composition requirement semantics, so if
-        only initialization time command construction is needed, use DeferredCommand instead.
-
-        :param supplier: the command supplier
-        This constructor's similarity to DeferredCommand is confusing and opens
-        potential footguns for users who do not fully understand the semantics and implications of
-        proxying, but who simply want runtime construction. Users who do know what they are doing
-        and need a supplier-constructed proxied command should instead proxy a DeferredCommand
-        using the ``asProxy`` decorator.
-        """
-        ...
-
-    @overload
     def __init__(self, command: Command):
         """
         Creates a new ProxyCommand that schedules the given command when initialized, and ends when it
@@ -48,47 +26,12 @@ class ProxyCommand(Command):
 
         :param command: the command to run by proxy
         """
-        ...
-
-    def __init__(self, *args, **kwargs):
         super().__init__()
 
-        def init_supplier(supplier: Callable[[], Command]):
-            assert callable(supplier)
-            self._supplier = supplier
-            warnings.warn(
-                "The ProxyCommand supplier constructor has been deprecated",
-                DeprecationWarning,
-                stacklevel=3,
-            )
-
-        def init_command(command: Command):
-            self.setName(f"Proxy({command.getName()})")
-            self._supplier = lambda: command
-
-        num_args = len(args) + len(kwargs)
-
-        if num_args == 1 and len(kwargs) == 1:
-            if "supplier" in kwargs:
-                return init_supplier(kwargs["supplier"])
-            elif "command" in kwargs:
-                return init_command(kwargs["command"])
-        elif num_args == 1 and len(args) == 1:
-            if isinstance(args[0], Command):
-                return init_command(args[0])
-            elif callable(args[0]):
-                return init_supplier(args[0])
-
-        raise TypeError(f"""
-TypeError: ProxyCommand(): incompatible function arguments. The following argument types are supported:
-    1. (self: ProxyCommand, supplier: () -> Command)
-    2. (self: ProxyCommand, command: Command)
-
-Invoked with: {format_args_kwargs(self, *args, **kwargs)}
-""")
+        self.setName(f"Proxy({command.getName()})")
+        self._command = command
 
     def initialize(self):
-        self._command = self._supplier()
         self._command.schedule()
 
     def end(self, interrupted: bool):