Merge pull request #13 from robotpy/2023-beta

2023 beta

Author: virtuald

.github/workflows/dist.yml

@@ -4,12 +4,14 @@ name: dist
 on:
   pull_request:
   push:
+    branches:
+    - main
     tags:
     - '*'
 
 jobs:
   ci:
-    uses: robotpy/build-actions/.github/workflows/package-ci.yml@v2022
+    uses: robotpy/build-actions/.github/workflows/package-ci.yml@v2023
     with:
       enable_sphinx_check: false
     secrets:

commands2/__init__.py

@@ -8,7 +8,6 @@
     CommandBase,
     CommandGroupBase,
     CommandScheduler,
-    CommandState,
     ConditionalCommand,
     FunctionalCommand,
     InstantCommand,
@@ -25,6 +24,7 @@
     ProfiledPIDSubsystem,
     ProxyScheduleCommand,
     RamseteCommand,
+    RepeatCommand,
     RunCommand,
     ScheduleCommand,
     SequentialCommandGroup,
@@ -44,6 +44,7 @@
     WaitCommand,
     WaitUntilCommand,
     # button,
+    # cmd,
     requirementsDisjoint,
 )
 
@@ -52,7 +53,6 @@
     "CommandBase",
     "CommandGroupBase",
     "CommandScheduler",
-    "CommandState",
     "ConditionalCommand",
     "FunctionalCommand",
     "InstantCommand",
@@ -69,6 +69,7 @@
     "ProfiledPIDSubsystem",
     "ProxyScheduleCommand",
     "RamseteCommand",
+    "RepeatCommand",
     "RunCommand",
     "ScheduleCommand",
     "SequentialCommandGroup",
@@ -88,5 +89,6 @@
     "WaitCommand",
     "WaitUntilCommand",
     # "button",
+    # "cmd",
     "requirementsDisjoint",
 ]

commands2/button/__init__.py

@@ -1,4 +1,22 @@
 # autogenerated by 'robotpy-build create-imports commands2.button commands2._impl.button'
-from .._impl.button import Button, JoystickButton, NetworkButton, POVButton
+from .._impl.button import (
+    Button,
+    CommandGenericHID,
+    CommandJoystick,
+    CommandPS4Controller,
+    CommandXboxController,
+    JoystickButton,
+    NetworkButton,
+    POVButton,
+)
 
-__all__ = ["Button", "JoystickButton", "NetworkButton", "POVButton"]
+__all__ = [
+    "Button",
+    "CommandGenericHID",
+    "CommandJoystick",
+    "CommandPS4Controller",
+    "CommandXboxController",
+    "JoystickButton",
+    "NetworkButton",
+    "POVButton",
+]

commands2/cmd/__init__.py

@@ -0,0 +1,34 @@
+# autogenerated by 'robotpy-build create-imports commands2.cmd commands2._impl.cmd'
+from .._impl.cmd import (
+    deadline,
+    either,
+    nothing,
+    parallel,
+    print,
+    race,
+    repeatingSequence,
+    run,
+    runEnd,
+    runOnce,
+    sequence,
+    startEnd,
+    wait,
+    waitUntil,
+)
+
+__all__ = [
+    "deadline",
+    "either",
+    "nothing",
+    "parallel",
+    "print",
+    "race",
+    "repeatingSequence",
+    "run",
+    "runEnd",
+    "runOnce",
+    "sequence",
+    "startEnd",
+    "wait",
+    "waitUntil",
+]

commands2/src/Command.cpp.inl

@@ -11,14 +11,14 @@
 
 cls_Command
   .def("andThen",
-    [](std::shared_ptr<Command> self, std::function<void()> toRun, wpi::span<std::shared_ptr<Subsystem>> requirements) {
+    [](std::shared_ptr<Command> self, std::function<void()> toRun, std::span<std::shared_ptr<Subsystem>> requirements) {
       std::vector<std::shared_ptr<Command>> temp;
       temp.emplace_back(self);
       temp.emplace_back(
           std::make_shared<InstantCommand>(std::move(toRun), requirements));
       return SequentialCommandGroup(std::move(temp));
     },
-    py::arg("toRun"), py::arg("requirements") = wpi::span<std::shared_ptr<Subsystem>>{},
+    py::arg("toRun"), py::arg("requirements") = std::span<std::shared_ptr<Subsystem>>{},
     "Decorates this command with a runnable to run after the command finishes.\n"
     DECORATOR_NOTE)
   .def("andThen",
@@ -62,13 +62,13 @@ cls_Command
     DECORATOR_NOTE
   )
   .def("beforeStarting",
-    [](std::shared_ptr<Command> self, std::function<void()> toRun, wpi::span<std::shared_ptr<Subsystem>> requirements) {
+    [](std::shared_ptr<Command> self, std::function<void()> toRun, std::span<std::shared_ptr<Subsystem>> requirements) {
       std::vector<std::shared_ptr<Command>> temp;
       temp.emplace_back(std::make_shared<InstantCommand>(std::move(toRun), requirements));
       temp.emplace_back(self);
       return std::make_shared<SequentialCommandGroup>(std::move(temp));
     },
-    py::arg("toRun"), py::arg("requirements")=wpi::span<std::shared_ptr<Subsystem> >{},
+    py::arg("toRun"), py::arg("requirements")=std::span<std::shared_ptr<Subsystem> >{},
     "Decorates this command with a runnable to run before this command starts.\n"
     "\n"
     ":param toRun:        the Runnable to run\n"

commands2/src/Subsystem.cpp.inl

@@ -4,16 +4,20 @@
 
 #include "frc2/command/Command.h"
 
+#include "frc2/command/CommandHelper.h"
 #include "frc2/command/CommandScheduler.h"
+#include "frc2/command/ConditionalCommand.h"
 #include "frc2/command/InstantCommand.h"
 #include "frc2/command/ParallelCommandGroup.h"
 #include "frc2/command/ParallelDeadlineGroup.h"
 #include "frc2/command/ParallelRaceGroup.h"
 #include "frc2/command/PerpetualCommand.h"
 #include "frc2/command/ProxyScheduleCommand.h"
+#include "frc2/command/RepeatCommand.h"
 #include "frc2/command/SequentialCommandGroup.h"
 #include "frc2/command/WaitCommand.h"
 #include "frc2/command/WaitUntilCommand.h"
+#include "frc2/command/WrapperCommand.h"
 
 #include <src/helpers.h>
 
@@ -33,34 +37,42 @@ void Command::Execute() {}
 void Command::End(bool interrupted) {}
 
 /*
-ParallelRaceGroup Command::WithTimeout(units::second_t duration) && {
-  std::vector<std::unique_ptr<Command>> temp;
-  temp.emplace_back(std::make_unique<WaitCommand>(duration));
-  temp.emplace_back(std::move(*this).TransferOwnership());
-  return ParallelRaceGroup(std::move(temp));
+CommandPtr Command::WithTimeout(units::second_t duration) && {
+  return CommandPtr(std::move(*this).TransferOwnership()).WithTimeout(duration);
 }
 */
 
 /*
-ParallelRaceGroup Command::Until(std::function<bool()> condition) && {
-  std::vector<std::unique_ptr<Command>> temp;
-  temp.emplace_back(std::make_unique<WaitUntilCommand>(std::move(condition)));
-  temp.emplace_back(std::move(*this).TransferOwnership());
-  return ParallelRaceGroup(std::move(temp));
+CommandPtr Command::Until(std::function<bool()> condition) && {
+  return CommandPtr(std::move(*this).TransferOwnership())
+      .Until(std::move(condition));
 }
 */
 
 /*
-ParallelRaceGroup Command::WithInterrupt(std::function<bool()> condition) && {
-  std::vector<std::unique_ptr<Command>> temp;
-  temp.emplace_back(std::make_unique<WaitUntilCommand>(std::move(condition)));
-  temp.emplace_back(std::move(*this).TransferOwnership());
-  return ParallelRaceGroup(std::move(temp));
+CommandPtr Command::IgnoringDisable(bool doesRunWhenDisabled) && {
+  return CommandPtr(std::move(*this).TransferOwnership())
+      .IgnoringDisable(doesRunWhenDisabled);
 }
 */
 
 /*
-SequentialCommandGroup Command::BeforeStarting(
+CommandPtr Command::WithInterruptBehavior(
+    InterruptionBehavior interruptBehavior) && {
+  return CommandPtr(std::move(*this).TransferOwnership())
+      .WithInterruptBehavior(interruptBehavior);
+}
+*/
+
+/*
+CommandPtr Command::WithInterrupt(std::function<bool()> condition) && {
+  return CommandPtr(std::move(*this).TransferOwnership())
+      .Until(std::move(condition));
+}
+*/
+
+/*
+CommandPtr Command::BeforeStarting(
     std::function<void()> toRun,
     std::initializer_list<Subsystem*> requirements) && {
   return std::move(*this).BeforeStarting(
@@ -69,54 +81,72 @@ SequentialCommandGroup Command::BeforeStarting(
 */
 
 /*
-SequentialCommandGroup Command::BeforeStarting(
-    std::function<void()> toRun, wpi::span<Subsystem* const> requirements) && {
-  std::vector<std::unique_ptr<Command>> temp;
-  temp.emplace_back(
-      std::make_unique<InstantCommand>(std::move(toRun), requirements));
-  temp.emplace_back(std::move(*this).TransferOwnership());
-  return SequentialCommandGroup(std::move(temp));
+CommandPtr Command::BeforeStarting(
+    std::function<void()> toRun, std::span<Subsystem* const> requirements) && {
+  return CommandPtr(std::move(*this).TransferOwnership())
+      .BeforeStarting(std::move(toRun), requirements);
 }
 */
 
 /*
-SequentialCommandGroup Command::AndThen(
-    std::function<void()> toRun,
-    std::initializer_list<Subsystem*> requirements) && {
+CommandPtr Command::AndThen(std::function<void()> toRun,
+                            std::initializer_list<Subsystem*> requirements) && {
   return std::move(*this).AndThen(std::move(toRun),
                                   {requirements.begin(), requirements.end()});
 }
 */
 
 /*
-SequentialCommandGroup Command::AndThen(
-    std::function<void()> toRun, wpi::span<Subsystem* const> requirements) && {
-  std::vector<std::unique_ptr<Command>> temp;
-  temp.emplace_back(std::move(*this).TransferOwnership());
-  temp.emplace_back(
-      std::make_unique<InstantCommand>(std::move(toRun), requirements));
-  return SequentialCommandGroup(std::move(temp));
+CommandPtr Command::AndThen(std::function<void()> toRun,
+                            std::span<Subsystem* const> requirements) && {
+  return CommandPtr(std::move(*this).TransferOwnership())
+      .AndThen(std::move(toRun), requirements);
 }
 */
 
 /*
 PerpetualCommand Command::Perpetually() && {
+  WPI_IGNORE_DEPRECATED
   return PerpetualCommand(std::move(*this).TransferOwnership());
+  WPI_UNIGNORE_DEPRECATED
+}
+*/
+
+/*
+CommandPtr Command::Repeatedly() && {
+  return CommandPtr(std::move(*this).TransferOwnership()).Repeatedly();
+}
+*/
+
+/*
+CommandPtr Command::AsProxy() && {
+  return CommandPtr(std::move(*this).TransferOwnership()).AsProxy();
 }
 */
 
 /*
-ProxyScheduleCommand Command::AsProxy() {
-  return ProxyScheduleCommand(this);
+CommandPtr Command::Unless(std::function<bool()> condition) && {
+  return CommandPtr(std::move(*this).TransferOwnership())
+      .Unless(std::move(condition));
 }
 */
 
-void frc2::Command_Schedule(std::shared_ptr<Command> self, bool interruptible) {
-  CommandScheduler::GetInstance().Schedule(interruptible, self);
+/*
+CommandPtr Command::FinallyDo(std::function<void(bool)> end) && {
+  return CommandPtr(std::move(*this).TransferOwnership())
+      .FinallyDo(std::move(end));
+}
+*/
+
+/*
+CommandPtr Command::HandleInterrupt(std::function<void(void)> handler) && {
+  return CommandPtr(std::move(*this).TransferOwnership())
+      .HandleInterrupt(std::move(handler));
 }
+*/
 
 void frc2::Command_Schedule(std::shared_ptr<Command> self) {
-  CommandScheduler::GetInstance().Schedule(true, self);
+  CommandScheduler::GetInstance().Schedule(self);
 }
 
 void Command::Cancel() {
@@ -127,10 +157,10 @@ bool Command::IsScheduled() {
   return CommandScheduler::GetInstance().IsScheduled(this);
 }
 
-bool Command::HasRequirement(std::shared_ptr<Subsystem> requirement) const {
+bool Command::HasRequirement(Subsystem* requirement) const {
   bool hasRequirement = false;
   for (auto&& subsystem : GetRequirements()) {
-    hasRequirement |= requirement == subsystem;
+    hasRequirement |= requirement == subsystem.get();
   }
   return hasRequirement;
 }

commands2/src/Trigger.cpp.inl

@@ -20,7 +20,7 @@ void CommandBase::AddRequirements(
   m_requirements.insert(requirements.begin(), requirements.end());
 }
 
-void CommandBase::AddRequirements(wpi::span<std::shared_ptr<Subsystem>> requirements) {
+void CommandBase::AddRequirements(std::span<std::shared_ptr<Subsystem>> requirements) {
   m_requirements.insert(requirements.begin(), requirements.end());
 }