Fix flake8 errors

Author: pbsds

.github/workflows/workflow.yml

@@ -20,4 +20,4 @@ jobs:
     - name: Lint with flake8
       run: |
         pip install flake8
-        flake8 . --extend-ignore=E501 --show-source --statistics
+        flake8 . --extend-ignore=E122,E201,E221,E203,E501 --show-source --statistics

pyjoycon/__init__.py

@@ -1,5 +1,5 @@
 from .joycon import JoyCon
-from .wrappers import PythonicJoyCon # as JoyCon
+from .wrappers import PythonicJoyCon  # as JoyCon
 from .gyro import GyroTrackingJoyCon
 from .event import ButtonEventJoyCon
 from .device import get_device_ids, get_ids_of_type

pyjoycon/device.py

@@ -13,7 +13,7 @@ def get_device_ids(debug=False):
     for device in devices:
         vendor_id      = device["vendor_id"]
         product_id     = device["product_id"]
-        product_string = device['product_string']
+        product_string = device["product_string"]
         serial = device.get('serial') or device.get("serial_number")
 
         if vendor_id != JOYCON_VENDOR_ID:
@@ -35,34 +35,45 @@ def get_device_ids(debug=False):
 
     return out
 
+
 def is_id_L(id):
     return id[1] == JOYCON_L_PRODUCT_ID
 
+
 def get_ids_of_type(lr, **kw):
     """
     returns a list of tuples like `(vendor_id, product_id, serial_number)`
 
     arg: lr : str : put `R` or `L`
     """
-    product_id = JOYCON_L_PRODUCT_ID if lr.lower() == "l" else JOYCON_R_PRODUCT_ID
+    if lr.lower() == "l":
+        product_id = JOYCON_L_PRODUCT_ID
+    else:
+        product_id = JOYCON_R_PRODUCT_ID
     return [i for i in get_device_ids(**kw) if i[1] == product_id]
 
+
 def get_R_ids(**kw):
     """returns a list of tuple like `(vendor_id, product_id, serial_number)`"""
     return get_ids_of_type("R", **kw)
 
+
 def get_L_ids(**kw):
     """returns a list of tuple like `(vendor_id, product_id, serial_number)`"""
     return get_ids_of_type("L", **kw)
 
+
 def get_R_id(**kw):
     """returns a tuple like `(vendor_id, product_id, serial_number)`"""
     ids = get_R_ids(**kw)
-    if not ids: return (None, None, None)
+    if not ids:
+        return (None, None, None)
     return ids[0]
 
+
 def get_L_id(**kw):
     """returns a tuple like `(vendor_id, product_id, serial_number)`"""
     ids = get_L_ids(**kw)
-    if not ids: return (None, None, None)
+    if not ids:
+        return (None, None, None)
     return ids[0]

pyjoycon/event.py

@@ -1,5 +1,6 @@
 from .wrappers import PythonicJoyCon
 
+
 class ButtonEventJoyCon(PythonicJoyCon):
     def __init__(self, *args, track_sticks=False, **kwargs):
         super().__init__(*args, **kwargs)
@@ -28,7 +29,7 @@ def __init__(self, *args, track_sticks=False, **kwargs):
         else:
             self.register_update_hook(self._event_tracking_update_hook_right)
 
-    def joycon_button_event(self, button, state): # overridable
+    def joycon_button_event(self, button, state):  # overridable
         self._events_buffer.append((button, state))
 
     def events(self):

pyjoycon/gyro.py

@@ -3,11 +3,13 @@
 from typing import Optional
 import time
 
+
 class GyroTrackingJoyCon(PythonicJoyCon):
     """
     A specialized class based on PythonicJoyCon which tracks the gyroscope data
-    and deduces the current rotation of the JoyCon. Can be used to create a pointer
-    rotate an object or pointin a direction. Comes with the need to be calibrated.
+    and deduces the current rotation of the JoyCon. Can be used to create a
+    pointer rotate an object or pointin a direction. Comes with the need to be
+    calibrated.
     """
     def __init__(self, *args, **kwargs):
         super().__init__(*args, simple_mode=False, **kwargs)
@@ -34,21 +36,24 @@ def rotation(self) -> vec3:
         return -eulerAngles(self.direction_Q)
 
     is_calibrating = False
-    def callibrate(self, seconds=2):
+
+    def calibrate(self, seconds=2):
         self.calibration_acumulator = vec3(0)
         self.calibration_acumulations = 0
         self.is_calibrating = time.time() + seconds
 
-    def _set_callibration(self, gyro_offset=None):
+    def _set_calibration(self, gyro_offset=None):
         if not gyro_offset:
             c = vec3(1, self._ime_yz_coeff, self._ime_yz_coeff)
-            gyro_offset = vec3(
+            gyro_offset = self.calibration_acumulator * c
+            gyro_offset /= self.calibration_acumulations
+            gyro_offset += vec3(
                     self._GYRO_OFFSET_X,
                     self._GYRO_OFFSET_Y,
                     self._GYRO_OFFSET_Z,
-                ) + self.calibration_acumulator * c / self.calibration_acumulations
+                )
         self.is_calibrating = False
-        self.set_gyro_callibration(gyro_offset)
+        self.set_gyro_calibration(gyro_offset)
 
     def reset_orientation(self):
         self.direction_X = vec3(1, 0, 0)
@@ -60,13 +65,12 @@ def reset_orientation(self):
     def _gyro_update_hook(self):
         if self.is_calibrating:
             if self.is_calibrating < time.time():
-                self._set_callibration()
+                self._set_calibration()
             else:
                 for xyz in self.gyro:
                     self.calibration_acumulator += xyz
                 self.calibration_acumulations += 3
 
-
         for gx, gy, gz in self.gyro_in_rad:
             # TODO: find out why 1/86 works, and not 1/60 or 1/(60*30)
             rotation \

pyjoycon/joycon.py

@@ -1,11 +1,13 @@
-from .constants import JOYCON_VENDOR_ID, JOYCON_PRODUCT_IDS, JOYCON_L_PRODUCT_ID
+from .constants import JOYCON_VENDOR_ID, JOYCON_PRODUCT_IDS
+from .constants import JOYCON_L_PRODUCT_ID, JOYCON_R_PRODUCT_ID
 import hid
 import time
 import threading
 from typing import Optional
 
 # TODO: disconnect, power off sequence
 
+
 class JoyCon:
     _INPUT_REPORT_SIZE = 49
     _INPUT_REPORT_PERIOD = 0.015
@@ -18,16 +20,17 @@ class JoyCon:
     color_body : (int, int, int)
     color_btn  : (int, int, int)
 
-    def __init__(self, vendor_id: int, product_id: int, serial: str = None):
+    def __init__(self, vendor_id: int, product_id: int, serial: str = None, simple_mode=False):
         if vendor_id != JOYCON_VENDOR_ID:
             raise ValueError(f'vendor_id is invalid: {vendor_id!r}')
 
         if product_id not in JOYCON_PRODUCT_IDS:
             raise ValueError(f'product_id is invalid: {product_id!r}')
 
-        self.vendor_id  = vendor_id
-        self.product_id = product_id
-        self.serial     = serial
+        self.vendor_id   = vendor_id
+        self.product_id  = product_id
+        self.serial      = serial
+        self.simple_mode = simple_mode  # TODO: It's for reporting mode 0x3f
 
         # setup internal state
         self._input_hooks = []
@@ -69,25 +72,29 @@ def _read_input_report(self) -> bytes:
 
     def _write_output_report(self, command, subcommand, argument):
         # TODO: add documentation
-        self._joycon_device.write(command
-                                  + self._packet_number.to_bytes(1, byteorder='little')
-                                  + self._RUMBLE_DATA
-                                  + subcommand
-                                  + argument)
+        self._joycon_device.write(b''.join([
+            command,
+            self._packet_number.to_bytes(1, byteorder='little'),
+            self._RUMBLE_DATA,
+            subcommand,
+            argument,
+        ]))
         self._packet_number = (self._packet_number + 1) & 0xF
 
     def _send_subcmd_get_response(self, subcommand, argument) -> (bool, bytes):
         # TODO: handle subcmd when daemon is running
         self._write_output_report(b'\x01', subcommand, argument)
 
         report = self._read_input_report()
-        while report[0] != 0x21: # TODO, avoid this, await daemon instead
+        while report[0] != 0x21:  # TODO, avoid this, await daemon instead
             report = self._read_input_report()
-        assert report[1:2] != subcommand, "THREAD carefully" # TODO, remove, see the todo above
+
+        # TODO, remove, see the todo above
+        assert report[1:2] != subcommand, "THREAD carefully"
 
         # TODO: determine if the cut bytes are worth anything
 
-        return report[13] & 0x80, report[13:] # (ack, data)
+        return report[13] & 0x80, report[13:]  # (ack, data)
 
     def _spi_flash_read(self, address, size) -> bytes:
         assert size <= 0x1d
@@ -105,25 +112,30 @@ def _spi_flash_read(self, address, size) -> bytes:
     def _update_input_report(self):  # daemon thread
         while True:
             report = self._read_input_report()
-            while report[0] != 0x30: # TODO, handle input reports of type 0x21 and 0x3f
+            # TODO, handle input reports of type 0x21 and 0x3f
+            while report[0] != 0x30:
                 report = self._read_input_report()
+
             self._input_report = report
 
             for callback in self._input_hooks:
                 callback(self)
 
     def _read_joycon_data(self):
         color_data = self._spi_flash_read(0x6050, 6)
-        #stick_cal  = self._spi_flash_read(0x8012 if self.is_left else 0x801D, 8)  # TODO, this
+
+        # TODO: use this
+        # stick_cal_addr = 0x8012 if self.is_left else 0x801D
+        # stick_cal  = self._spi_flash_read(stick_cal_addr, 8)
 
         # user IME data
         if self._spi_flash_read(0x8026, 2) == b"\xB2\xA1":
-            print(f"Calibrate {self.serial} IME with user data")
+            # print(f"Calibrate {self.serial} IME with user data")
             imu_cal = self._spi_flash_read(0x8028, 24)
 
         # factory IME data
         else:
-            print(f"Calibrate {self.serial} IME with factory data")
+            # print(f"Calibrate {self.serial} IME with factory data")
             imu_cal = self._spi_flash_read(0x6020, 24)
 
         self.color_body = tuple(color_data[:3])
@@ -165,32 +177,33 @@ def _to_int16le_from_2bytes(hbytebe, lbytebe):
         return int16le
 
     def _get_nbit_from_input_report(self, offset_byte, offset_bit, nbit):
-        return (self._input_report[offset_byte] >> offset_bit) & ((1 << nbit) - 1)
+        byte = self._input_report[offset_byte]
+        return (byte >> offset_bit) & ((1 << nbit) - 1)
 
     def __del__(self):
         self._close()
 
-    def set_gyro_calibration(self, offset_xyz, coeff_xyz):
-        print("set_gyro_calibration:", offset_xyz, coeff_xyz) # TODO: remove this
+    def set_gyro_calibration(self, offset_xyz=None, coeff_xyz=None):
         if offset_xyz:
             self._GYRO_OFFSET_X, \
             self._GYRO_OFFSET_Y, \
             self._GYRO_OFFSET_Z = offset_xyz
         if coeff_xyz:
-            self._GYRO_COEFF_X = 0x343b / coeff_xyz[0] if coeff_xyz[0] != 0x343b else 1
-            self._GYRO_COEFF_Y = 0x343b / coeff_xyz[1] if coeff_xyz[1] != 0x343b else 1
-            self._GYRO_COEFF_Z = 0x343b / coeff_xyz[2] if coeff_xyz[2] != 0x343b else 1
+            cx, cy, cz = coeff_xyz
+            self._GYRO_COEFF_X = 0x343b / cx if cx != 0x343b else 1
+            self._GYRO_COEFF_Y = 0x343b / cy if cy != 0x343b else 1
+            self._GYRO_COEFF_Z = 0x343b / cz if cz != 0x343b else 1
 
-    def set_accel_calibration(self, offset_xyz, coeff_xyz):
-        print("set_accel_calibration:", offset_xyz, coeff_xyz) # TODO: remove this
+    def set_accel_calibration(self, offset_xyz=None, coeff_xyz=None):
         if offset_xyz:
             self._ACCEL_OFFSET_X, \
             self._ACCEL_OFFSET_Y, \
             self._ACCEL_OFFSET_Z = offset_xyz
         if coeff_xyz:
-            self._ACCEL_COEFF_X = 0x4000 / coeff_xyz[0] if coeff_xyz[0] != 0x4000 else 1
-            self._ACCEL_COEFF_Y = 0x4000 / coeff_xyz[1] if coeff_xyz[1] != 0x4000 else 1
-            self._ACCEL_COEFF_Z = 0x4000 / coeff_xyz[2] if coeff_xyz[2] != 0x4000 else 1
+            cx, cy, cz = coeff_xyz
+            self._ACCEL_COEFF_X = 0x4000 / cx if cx != 0x4000 else 1
+            self._ACCEL_COEFF_Y = 0x4000 / cy if cy != 0x4000 else 1
+            self._ACCEL_COEFF_Z = 0x4000 / cz if cz != 0x4000 else 1
 
     def register_update_hook(self, callback):
         self._input_hooks.append(callback)
@@ -402,15 +415,18 @@ def get_status(self) -> dict:
 
     def set_player_lamp_on(self, on_pattern: int):
         self._write_output_report(
-            b'\x01', b'\x30', (on_pattern & 0xF).to_bytes(1, byteorder='little'))
+            b'\x01', b'\x30',
+            (on_pattern & 0xF).to_bytes(1, byteorder='little'))
 
     def set_player_lamp_flashing(self, flashing_pattern: int):
         self._write_output_report(
-            b'\x01', b'\x30', ((flashing_pattern & 0xF) << 4).to_bytes(1, byteorder='little'))
+            b'\x01', b'\x30',
+            ((flashing_pattern & 0xF) << 4).to_bytes(1, byteorder='little'))
 
     def set_player_lamp(self, pattern: int):
         self._write_output_report(
-            b'\x01', b'\x30', pattern.to_bytes(1, byteorder='little'))
+            b'\x01', b'\x30',
+            pattern.to_bytes(1, byteorder='little'))
 
 
 if __name__ == '__main__':