Reformatted master.

commands/autoconfig.py

@@ -32,17 +32,20 @@ def init():
     try:
         val = definedAutos[0]
         for auto in definedAutos:
-            if auto[-1] == '0':
+            if auto[-1] == "0":
                 val = auto
         table.putString("selectedAuto", val)
-    except(IndexError):
+    except (IndexError):
         table.putString("selectedAuto", "NO AUTO FOUND")
 
+
 def getAutoProgram():
     """
     Returns the first defined auto if none are selected.
     """
     try:
-        return table.getString("selectedAuto", (definedAutos[0]).lower()) # Should never call the default here since default is populated above.
-    except(IndexError):
+        return table.getString(
+            "selectedAuto", (definedAutos[0]).lower()
+        )  # Should never call the default here since default is populated above.
+    except (IndexError):
         raise Exception("You don't have any autos defined!")

commands/autonomouscommandgroup.py

@@ -24,14 +24,14 @@ def __init__(self):
             if var.lower() == self.currentAuto:
                 toRun = var
                 break
-                        
+
         eval("self." + toRun + "()")  # Runs the method
 
     def example(self):
         """
         Define the function using the name of the autonomous program. It should
         then appear on the driverstation. Put a exclamation point in front of the chosen
-        default one! If there is no default selected, the default will be the auto first 
+        default one! If there is no default selected, the default will be the auto first
         in alphabetical order.
         """
         pass

commands/drivetrain/drivecommand.py

@@ -6,9 +6,10 @@
 from custom import driverhud
 import math
 
-logicalaxes.registerAxis('driveX')
-logicalaxes.registerAxis('driveY')
-logicalaxes.registerAxis('driveRotate')
+logicalaxes.registerAxis("driveX")
+logicalaxes.registerAxis("driveY")
+logicalaxes.registerAxis("driveRotate")
+
 
 class DriveCommand(CommandBase):
     def __init__(self):
@@ -19,11 +20,10 @@ def __init__(self):
     def initialize(self):
         robot.drivetrain.stop()
         robot.drivetrain.setProfile(0)
-        
+
         self.lastY = None
         self.slowed = False
 
-
     def execute(self):
         # Avoid quick changes in direction
         y = logicalaxes.driveY.get()
@@ -46,7 +46,5 @@ def execute(self):
             correction = 0
 
         robot.drivetrain.move(
-            logicalaxes.driveX.get(),
-            y - correction,
-            logicalaxes.driveRotate.get()
+            logicalaxes.driveX.get(), y - correction, logicalaxes.driveRotate.get()
         )

commands/drivetrain/movecommand.py

@@ -16,9 +16,9 @@ def __init__(self, distance, angle=0, tolerance=5, slow=False, name=None):
             name = "Move %f inches" % distance
 
         super().__init__()
-        
+
         if isinstance(robot.drivetain, SwerveDrive):
-            
+
             self.distance = -distance
             self.angle = angle
             self.tol = tolerance  # Angle tolerance in degrees.

commands/drivetrain/pivotcommand.py

@@ -7,11 +7,11 @@
 
 
 class PivotCommand(TurnCommand):
-    '''Allows autonomous turning using the drive base encoders.'''
+    """Allows autonomous turning using the drive base encoders."""
 
     def __init__(self, degrees, reverse=False, name=None):
         if name is None:
-            name = 'Pivot %f degrees' % degrees
+            name = "Pivot %f degrees" % degrees
 
         super().__init__(degrees, name)
 
@@ -23,9 +23,8 @@ def __init__(self, degrees, reverse=False, name=None):
         if reverse:
             self.pivotSide = abs(self.pivotSide - 1)
 
-
     def initialize(self):
-        '''Calculates new positions by offsetting the current ones.'''
+        """Calculates new positions by offsetting the current ones."""
 
         offset = self._calculateDisplacement() * 2
         targetPositions = []

commands/drivetrain/pivottocommand.py

@@ -2,20 +2,16 @@
 
 import robot
 
+
 class PivotToCommand(PivotCommand):
-    '''Pivot to a specified angle using the gyroscope.'''
+    """Pivot to a specified angle using the gyroscope."""
 
     def __init__(self, targetDegrees, reverse=False):
-        super().__init__(
-            targetDegrees,
-            reverse,
-            'Pivot to %f degrees' % targetDegrees
-        )
+        super().__init__(targetDegrees, reverse, "Pivot to %f degrees" % targetDegrees)
 
         self.targetDegrees = targetDegrees
         self.reversed = reverse
 
-
     def initialize(self):
         self.distance = robot.drivetrain.getAngleTo(self.targetDegrees)
 

commands/drivetrain/resettiltcommand.py

@@ -2,8 +2,8 @@
 
 import robot
 
-class ResetTiltCommand(InstantCommand):
 
+class ResetTiltCommand(InstantCommand):
     def __init__(self):
         super().__init__()
 

commands/drivetrain/setspeedcommand.py

@@ -2,13 +2,13 @@
 
 import robot
 
+
 class SetSpeedCommand(InstantCommand):
-    '''Changes the max speed of the drive subsystem.'''
+    """Changes the max speed of the drive subsystem."""
 
     def __init__(self, speed):
         super().__init__()
         self.speed = speed
 
-
     def initialize(self):
         robot.drivetrain.setSpeedLimit(self.speed)

commands/drivetrain/turncommand.py

@@ -7,17 +7,16 @@
 
 
 class TurnCommand(MoveCommand):
-    '''Allows autonomous turning using the drive base encoders.'''
+    """Allows autonomous turning using the drive base encoders."""
 
     def __init__(self, degrees, name=None):
         if name is None:
-            name = 'Turn %f degrees' % degrees
+            name = "Turn %f degrees" % degrees
 
         super().__init__(degrees, False, name)
 
-
     def initialize(self):
-        '''Calculates new positions by offseting the current ones.'''
+        """Calculates new positions by offseting the current ones."""
 
         offset = self._calculateDisplacement()
         targetPositions = []
@@ -26,15 +25,14 @@ def initialize(self):
 
         robot.drivetrain.setPositions(targetPositions)
 
-
     def _calculateDisplacement(self):
-        '''
+        """
         In order to avoid having a separate ticksPerDegree, we calculate it
         based on the width of the robot base.
-        '''
+        """
 
-        inchesPerDegree = math.pi * Config('DriveTrain/width') / 360
+        inchesPerDegree = math.pi * Config("DriveTrain/width") / 360
         totalDistanceInInches = self.distance * inchesPerDegree
         ticks = robot.drivetrain.inchesToTicks(totalDistanceInInches)
 
-        return ticks * Config('DriveTrain/slip', 1.2)
+        return ticks * Config("DriveTrain/slip", 1.2)

commands/drivetrain/turntocommand.py

@@ -2,18 +2,15 @@
 
 import robot
 
+
 class TurnToCommand(TurnCommand):
-    '''Turn to a specified angle using the gyroscope.'''
+    """Turn to a specified angle using the gyroscope."""
 
     def __init__(self, targetDegrees):
-        super().__init__(
-            targetDegrees,
-            'Turn to %f degrees' % targetDegrees
-        )
+        super().__init__(targetDegrees, "Turn to %f degrees" % targetDegrees)
 
         self.targetDegrees = targetDegrees
 
-
     def initialize(self):
         self.distance = robot.drivetrain.getAngleTo(self.targetDegrees)
 

commands/drivetrain/zerogyrocommand.py

@@ -2,13 +2,12 @@
 
 import robot
 
-class ZeroGyroCommand(InstantCommand):
 
+class ZeroGyroCommand(InstantCommand):
     def __init__(self):
-        super().__init__('Zero Gyro')
+        super().__init__("Zero Gyro")
 
         self.requires(robot.drivetrain)
 
-
     def initialize(self):
         robot.drivetrain.resetGyro()

commands/monitorcommand.py

@@ -2,21 +2,21 @@
 
 import robot
 
+
 class MonitorCommand(Command):
-    '''Runs continually while the robot is powered on.'''
+    """Runs continually while the robot is powered on."""
 
     def __init__(self):
-        super().__init__('MonitorCommand')
+        super().__init__("MonitorCommand")
 
-        '''
+        """
         Required because this is the default command for the monitor subsystem.
-        '''
+        """
         self.requires(robot.monitor)
 
         self.setInterruptible(False)
         self.setRunWhenDisabled(True)
 
-
     def execute(self):
-        '''Implement watchers here.'''
+        """Implement watchers here."""
         pass

commands/network/messagecommand.py

@@ -2,6 +2,7 @@
 
 from subsystems.cougarsystem import CougarSystem
 
+
 class MessageCommand(InstantCommand):
     def __init__(self, msg):
         super().__init__()

commands/resetcommand.py

@@ -2,16 +2,17 @@
 
 import robot
 
+
 class ResetCommand(InstantCommand):
-    '''
+    """
     Disable any running commands for all subsystems, except Monitor. This should
     be used to stop any motion and return the commands to a safe state. In
     general just requiring a subsystem will stop its current command. Additional
     resetting can be handled in the initialize method.
-    '''
+    """
 
     def __init__(self):
         super().__init__()
 
-        '''Require all subsystems to reset.'''
+        """Require all subsystems to reset."""
         self.addRequirements(robot.drivetrain)

commands/startupcommandgroup.py

@@ -4,8 +4,8 @@
 
 from .drivetrain.resettiltcommand import ResetTiltCommand
 
-class StartUpCommandGroup(ParallelCommandGroup):
 
+class StartUpCommandGroup(ParallelCommandGroup):
     def __init__(self):
         super().__init__()
 

commands/tools/calculateerrorcommand.py

@@ -4,6 +4,7 @@
 import robot
 from custom.config import Config
 
+
 class CalculateErrorCommand(MoveCommand):
 
     errors = []
@@ -12,15 +13,13 @@ def __init__(self, direction=1):
         super().__init__(30 * direction)
 
         self.addRequirements(robot.drivetrain)
-        Config('DriveTrain/wheelDiameter', 8)
-        self.table = NetworkTables.getTable('DriveTrain/Speed')
-
+        Config("DriveTrain/wheelDiameter", 8)
+        self.table = NetworkTables.getTable("DriveTrain/Speed")
 
     def initialize(self):
-        self.table.putValue('P', 0)
+        self.table.putValue("P", 0)
         super().initialize()
 
-
     def isFinished(self):
         if not self.isTimedOut():
             return False
@@ -35,9 +34,8 @@ def isFinished(self):
 
         return self.onTarget > 5
 
-
     def end(self):
         self.errors.append(robot.drivetrain.averageError())
 
         avgError = sum(self.errors) / len(self.errors)
-        self.table.putValue('P', 415 / avgError)
+        self.table.putValue("P", 415 / avgError)

commands/tools/calculatemaxspeedcommand.py

@@ -4,6 +4,7 @@
 
 import robot
 
+
 class CalculateMaxSpeedCommand(InstantCommand):
 
     measuredSpeeds = []
@@ -12,8 +13,7 @@ def __init__(self):
         super().__init__()
 
         self.addRequirements(robot.drivetrain)
-        self.table = NetworkTables.getTable('DriveTrain')
-
+        self.table = NetworkTables.getTable("DriveTrain")
 
     def initialize(self):
         for speed in robot.drivetrain.getSpeeds():
@@ -22,8 +22,8 @@ def initialize(self):
         # Select the smallest max speed
         maxSpeed = min(self.measuredSpeeds)
 
-        self.table.putValue('maxSpeed', math.floor(maxSpeed))
-        self.table.putValue('normalSpeed', round(maxSpeed * 0.7))
-        self.table.putValue('preciseSpeed', round(maxSpeed * 0.3))
+        self.table.putValue("maxSpeed", math.floor(maxSpeed))
+        self.table.putValue("normalSpeed", round(maxSpeed * 0.7))
+        self.table.putValue("preciseSpeed", round(maxSpeed * 0.3))
 
-        self.table.putValue('Speed/F', 1023 / maxSpeed)
+        self.table.putValue("Speed/F", 1023 / maxSpeed)