docs: def four_motor_swerve_drivetrain(
      lr_motor,
      rr_motor,
      lf_motor,
      rf_motor,
      lr_angle,
      rr_angle,
      lf_angle,
      rf_angle,
      x_wheelbase=2,
      y_wheelbase=2,
      speed=5,
      deadzone=None,
  ):
      """
          Four motors that can be rotated in any direction
          
          If any motors are inverted, then you will need to multiply that motor's
          value by -1.
          
          :param lr_motor:   Left rear motor value (-1 to 1); 1 is forward
          :param rr_motor:   Right rear motor value (-1 to 1); 1 is forward
          :param lf_motor:   Left front motor value (-1 to 1); 1 is forward
          :param rf_motor:   Right front motor value (-1 to 1); 1 is forward
          
          :param lr_angle:   Left rear motor angle in degrees (0 to 360 measured clockwise from forward position)
          :param rr_angle:   Right rear motor angle in degrees (0 to 360 measured clockwise from forward position)
          :param lf_angle:   Left front motor angle in degrees (0 to 360 measured clockwise from forward position)
          :param rf_angle:   Right front motor angle in degrees (0 to 360 measured clockwise from forward position)
          
          :param x_wheelbase: The distance in feet between right and left wheels.
          :param y_wheelbase: The distance in feet between forward and rear wheels.
          :param speed:      Speed of robot in feet per second (see above)
          :param deadzone:   A function that adjusts the output of the motor (see :func:`linear_deadzone`)
          
          :returns: Speed of robot in x (ft/s), Speed of robot in y (ft/s),
                    clockwise rotation of robot (radians/s)
      """
  
      if deadzone:
          lf_motor = deadzone(lf_motor)
          lr_motor = deadzone(lr_motor)
          rf_motor = deadzone(rf_motor)
          rr_motor = deadzone(rr_motor)
  
      # Calculate speed of each wheel
      lr = lr_motor * speed
      rr = rr_motor * speed
      lf = lf_motor * speed
      rf = rf_motor * speed
  
      # Calculate angle in radians
      lr_rad = math.radians(lr_angle)
      rr_rad = math.radians(rr_angle)
      lf_rad = math.radians(lf_angle)
      rf_rad = math.radians(rf_angle)
  
      # Calculate wheelbase radius
      wheelbase_radius = math.hypot(x_wheelbase / 2.0, y_wheelbase / 2.0)
  
      # Calculates the Vx and Vy components
      # Sin an Cos inverted because forward is 0 on swerve wheels
      Vx = (
          (math.sin(lr_rad) * lr)
          + (math.sin(rr_rad) * rr)
          + (math.sin(lf_rad) * lf)
          + (math.sin(rf_rad) * rf)
      )
      Vy = (
          (math.cos(lr_rad) * lr)
          + (math.cos(rr_rad) * rr)
          + (math.cos(lf_rad) * lf)
          + (math.cos(rf_rad) * rf)
      )
  
      # Adjusts the angle corresponding to a diameter that is perpendicular to the radius (add or subtract 45deg)
      lr_rad = (lr_rad + (math.pi / 4)) % (2 * math.pi)
      rr_rad = (rr_rad - (math.pi / 4)) % (2 * math.pi)
      lf_rad = (lf_rad - (math.pi / 4)) % (2 * math.pi)
      rf_rad = (rf_rad + (math.pi / 4)) % (2 * math.pi)
  
      # Finds the rotational velocity by finding the torque and adding them up
      Vw = wheelbase_radius * (
          (math.cos(lr_rad) * lr)
          + (math.cos(rr_rad) * -rr)
          + (math.cos(lf_rad) * lf)
          + (math.cos(rf_rad) * -rf)
      )
  
      Vx *= 0.25
      Vy *= 0.25
      Vw *= 0.25
  
      return Vx, Vy, Vw