Merge pull request #4362 from microDev1/code-formatting

Add code formatting and translations check

.github/workflows/build.yml

@@ -43,8 +43,6 @@ jobs:
       run: |
         gcc --version
         python3 --version
-    - name: Translations
-      run: make check-translate
     - name: New boards check
       run: python3 -u ci_new_boards_check.py
       working-directory: tools

.github/workflows/pre-commit.yml

@@ -7,7 +7,6 @@ name: pre-commit
 on:
   pull_request:
   push:
-    branches: [main]
 
 jobs:
   pre-commit:
@@ -16,10 +15,13 @@ jobs:
     - uses: actions/checkout@v1
     - uses: actions/setup-python@v1
     - name: Install deps
-      run: sudo apt-get update && sudo apt-get install -y gettext
+      run: |
+        sudo apt-add-repository -y -u ppa:pybricks/ppa
+        sudo apt-get install -y black gettext uncrustify
+        pip3 install polib
     - name: Populate selected submodules
       run: git submodule update --init extmod/ulab
-    - name: set PY
+    - name: Set PY
       run: echo >>$GITHUB_ENV PY="$(python -c 'import hashlib, sys;print(hashlib.sha256(sys.version.encode()+sys.executable.encode()).hexdigest())')"
     - uses: actions/cache@v2
       with:

.pre-commit-config.yaml

@@ -11,3 +11,16 @@ repos:
         exclude: '^(tests/.*\.exp|tests/cmdline/.*|tests/.*/data/.*|ports/esp32s2/esp-idf-config/.*|ports/esp32s2/boards/.*/sdkconfig)'
     -   id: trailing-whitespace
         exclude: '^(tests/.*\.exp|tests/cmdline/.*|tests/.*/data/.*)'
+-   repo: local
+    hooks:
+    -   id: translations
+        name: Translations
+        entry: sh -c "if ! make check-translate; then make translate; fi"
+        types: [c]
+        pass_filenames: false
+        language: system
+    -   id: formatting
+        name: Formatting
+        entry: sh -c "git diff --staged --name-only | xargs python3 tools/codeformat.py"
+        types_or: [c, python]
+        language: system

devices/ble_hci/common-hal/_bleio/Adapter.c

@@ -51,7 +51,7 @@
 
 #define MSEC_TO_UNITS(TIME, RESOLUTION) (((TIME) * 1000) / (RESOLUTION))
 #define SEC_TO_UNITS(TIME, RESOLUTION) (((TIME) * 1000000) / (RESOLUTION))
-#define UNITS_TO_SEC(TIME, RESOLUTION) (((TIME) * (RESOLUTION)) / 1000000)
+#define UNITS_TO_SEC(TIME, RESOLUTION) (((TIME)*(RESOLUTION)) / 1000000)
 // 0.625 msecs (625 usecs)
 #define ADV_INTERVAL_UNIT_FLOAT_SECS (0.000625)
 // Microseconds is the base unit. The macros above know that.
@@ -63,7 +63,7 @@
 
 // TODO make this settable from Python.
 #define DEFAULT_TX_POWER 0  // 0 dBm
-#define MAX_ANONYMOUS_ADV_TIMEOUT_SECS (60*15)
+#define MAX_ANONYMOUS_ADV_TIMEOUT_SECS (60 * 15)
 #define MAX_LIMITED_DISCOVERABLE_ADV_TIMEOUT_SECS (180)
 
 #define BLE_MIN_CONN_INTERVAL        MSEC_TO_UNITS(15, UNIT_0_625_MS)
@@ -289,7 +289,7 @@ STATIC void bleio_adapter_hci_init(bleio_adapter_obj_t *self) {
 
     // Get version information.
     if (hci_read_local_version(&self->hci_version, &self->hci_revision, &self->lmp_version,
-                               &self->manufacturer, &self->lmp_subversion) != HCI_OK) {
+        &self->manufacturer, &self->lmp_subversion) != HCI_OK) {
         mp_raise_bleio_BluetoothError(translate("Could not read HCI version"));
     }
     // Get supported features.
@@ -414,11 +414,11 @@ bool common_hal_bleio_adapter_set_address(bleio_adapter_obj_t *self, bleio_addre
     return hci_le_set_random_address(bufinfo.buf) == HCI_OK;
 }
 
-mp_obj_str_t* common_hal_bleio_adapter_get_name(bleio_adapter_obj_t *self) {
+mp_obj_str_t *common_hal_bleio_adapter_get_name(bleio_adapter_obj_t *self) {
     return self->name;
 }
 
-void common_hal_bleio_adapter_set_name(bleio_adapter_obj_t *self, const char* name) {
+void common_hal_bleio_adapter_set_name(bleio_adapter_obj_t *self, const char *name) {
     self->name = mp_obj_new_str(name, strlen(name));
     mp_buffer_info_t bufinfo;
     mp_get_buffer_raise(self->name, &bufinfo, MP_BUFFER_READ);
@@ -459,7 +459,7 @@ void common_hal_bleio_adapter_set_name(bleio_adapter_obj_t *self, const char* na
 //     return true;
 // }
 
-mp_obj_t common_hal_bleio_adapter_start_scan(bleio_adapter_obj_t *self, uint8_t* prefixes, size_t prefix_length, bool extended, mp_int_t buffer_size, mp_float_t timeout, mp_float_t interval, mp_float_t window, mp_int_t minimum_rssi, bool active) {
+mp_obj_t common_hal_bleio_adapter_start_scan(bleio_adapter_obj_t *self, uint8_t *prefixes, size_t prefix_length, bool extended, mp_int_t buffer_size, mp_float_t timeout, mp_float_t interval, mp_float_t window, mp_int_t minimum_rssi, bool active) {
     // TODO
     mp_raise_NotImplementedError(NULL);
     check_enabled(self);
@@ -704,7 +704,7 @@ uint32_t _common_hal_bleio_adapter_start_advertising(bleio_adapter_obj_t *self,
 
         uint8_t handle[1] = { 0 };
         uint16_t duration_10msec[1] = { timeout * 100 };
-        uint8_t max_ext_adv_evts[1] =  { 0 };
+        uint8_t max_ext_adv_evts[1] = { 0 };
         hci_check_error(
             hci_le_set_extended_advertising_enable(
                 BT_HCI_LE_ADV_ENABLE,
@@ -789,11 +789,11 @@ void common_hal_bleio_adapter_start_advertising(bleio_adapter_obj_t *self, bool
     } else {
         if (timeout > MAX_LIMITED_DISCOVERABLE_ADV_TIMEOUT_SECS) {
             mp_raise_bleio_BluetoothError(translate("Timeout is too long: Maximum timeout length is %d seconds"),
-                                          MAX_LIMITED_DISCOVERABLE_ADV_TIMEOUT_SECS);
+                MAX_LIMITED_DISCOVERABLE_ADV_TIMEOUT_SECS);
         }
     }
 
-    const uint32_t result =_common_hal_bleio_adapter_start_advertising(
+    const uint32_t result = _common_hal_bleio_adapter_start_advertising(
         self, connectable, anonymous, timeout, interval,
         advertising_data_bufinfo->buf,
         advertising_data_bufinfo->len,
@@ -820,11 +820,11 @@ void common_hal_bleio_adapter_stop_advertising(bleio_adapter_obj_t *self) {
         hci_check_error(result);
     }
 
-    //TODO startup CircuitPython advertising again.
+    // TODO startup CircuitPython advertising again.
 }
 
 // Note that something stopped advertising, such as a connection happening.
-//Don't ask the adapter to stop.
+// Don't ask the adapter to stop.
 void bleio_adapter_advertising_was_stopped(bleio_adapter_obj_t *self) {
     self->now_advertising = false;
     self->extended_advertising = false;
@@ -876,14 +876,14 @@ void common_hal_bleio_adapter_erase_bonding(bleio_adapter_obj_t *self) {
     mp_raise_NotImplementedError(NULL);
     check_enabled(self);
 
-    //FIX bonding_erase_storage();
+    // FIX bonding_erase_storage();
 }
 
 uint16_t bleio_adapter_add_attribute(bleio_adapter_obj_t *adapter, mp_obj_t *attribute) {
     check_enabled(adapter);
 
     // The handle is the index of this attribute in the attributes list.
-    uint16_t handle = (uint16_t) adapter->attributes->len;
+    uint16_t handle = (uint16_t)adapter->attributes->len;
     mp_obj_list_append(adapter->attributes, attribute);
 
     if (MP_OBJ_IS_TYPE(attribute, &bleio_service_type)) {
@@ -896,7 +896,7 @@ uint16_t bleio_adapter_add_attribute(bleio_adapter_obj_t *adapter, mp_obj_t *att
     return handle;
 }
 
-mp_obj_t* bleio_adapter_get_attribute(bleio_adapter_obj_t *adapter, uint16_t handle) {
+mp_obj_t *bleio_adapter_get_attribute(bleio_adapter_obj_t *adapter, uint16_t handle) {
     check_enabled(adapter);
 
     if (handle == 0 || handle >= adapter->attributes->len) {
@@ -912,12 +912,12 @@ uint16_t bleio_adapter_max_attribute_handle(bleio_adapter_obj_t *adapter) {
 }
 
 
-void bleio_adapter_gc_collect(bleio_adapter_obj_t* adapter) {
-    gc_collect_root((void**)adapter, sizeof(bleio_adapter_obj_t) / sizeof(size_t));
-    gc_collect_root((void**)bleio_connections, sizeof(bleio_connections) / sizeof(size_t));
+void bleio_adapter_gc_collect(bleio_adapter_obj_t *adapter) {
+    gc_collect_root((void **)adapter, sizeof(bleio_adapter_obj_t) / sizeof(size_t));
+    gc_collect_root((void **)bleio_connections, sizeof(bleio_connections) / sizeof(size_t));
 }
 
-void bleio_adapter_reset(bleio_adapter_obj_t* adapter) {
+void bleio_adapter_reset(bleio_adapter_obj_t *adapter) {
 
     if (!common_hal_bleio_adapter_get_enabled(adapter)) {
         return;
@@ -939,7 +939,7 @@ void bleio_adapter_reset(bleio_adapter_obj_t* adapter) {
 
 }
 
-void bleio_adapter_background(bleio_adapter_obj_t* adapter) {
+void bleio_adapter_background(bleio_adapter_obj_t *adapter) {
     if (!common_hal_bleio_adapter_get_enabled(adapter)) {
         return;
     }

devices/ble_hci/common-hal/_bleio/Adapter.h

@@ -49,7 +49,7 @@ typedef struct _bleio_adapter_obj_t {
     bleio_scanresults_obj_t *scan_results;
     mp_obj_t name;
     mp_obj_tuple_t *connection_objs;
-    busio_uart_obj_t* hci_uart;
+    busio_uart_obj_t *hci_uart;
     digitalio_digitalinout_obj_t *rts_digitalinout;
     digitalio_digitalinout_obj_t *cts_digitalinout;
     bool allocated;  // True when in use.
@@ -72,7 +72,7 @@ typedef struct _bleio_adapter_obj_t {
     // Generic services characteristics.
     bleio_characteristic_obj_t *device_name_characteristic;
     bleio_characteristic_obj_t *appearance_characteristic;
-    bleio_characteristic_obj_t * service_changed_characteristic;
+    bleio_characteristic_obj_t *service_changed_characteristic;
 
     uint16_t max_acl_buffer_len;
     uint16_t max_acl_num_buffers;
@@ -90,10 +90,10 @@ typedef struct _bleio_adapter_obj_t {
 
 uint16_t bleio_adapter_add_attribute(bleio_adapter_obj_t *adapter, mp_obj_t *attribute);
 void bleio_adapter_advertising_was_stopped(bleio_adapter_obj_t *self);
-mp_obj_t* bleio_adapter_get_attribute(bleio_adapter_obj_t *adapter, uint16_t handle);
+mp_obj_t *bleio_adapter_get_attribute(bleio_adapter_obj_t *adapter, uint16_t handle);
 uint16_t bleio_adapter_max_attribute_handle(bleio_adapter_obj_t *adapter);
-void bleio_adapter_background(bleio_adapter_obj_t* adapter);
-void bleio_adapter_gc_collect(bleio_adapter_obj_t* adapter);
-void bleio_adapter_reset(bleio_adapter_obj_t* adapter);
+void bleio_adapter_background(bleio_adapter_obj_t *adapter);
+void bleio_adapter_gc_collect(bleio_adapter_obj_t *adapter);
+void bleio_adapter_reset(bleio_adapter_obj_t *adapter);
 
 #endif // MICROPY_INCLUDED_BLE_HCI_COMMON_HAL_ADAPTER_H

devices/ble_hci/common-hal/_bleio/Characteristic.c

@@ -78,16 +78,16 @@ bleio_service_obj_t *common_hal_bleio_characteristic_get_service(bleio_character
     return self->service;
 }
 
-size_t common_hal_bleio_characteristic_get_value(bleio_characteristic_obj_t *self, uint8_t* buf, size_t len) {
+size_t common_hal_bleio_characteristic_get_value(bleio_characteristic_obj_t *self, uint8_t *buf, size_t len) {
     // Do GATT operations only if this characteristic has been added to a registered service.
     if (self->handle != BLE_GATT_HANDLE_INVALID) {
-        //FIX uint16_t conn_handle = bleio_connection_get_conn_handle(self->service->connection);
+        // FIX uint16_t conn_handle = bleio_connection_get_conn_handle(self->service->connection);
         if (common_hal_bleio_service_get_is_remote(self->service)) {
-            //FIX read remote chars
-            //uint8_t rsp[MAX(len, 512)];
-            //FIX improve att_read_req to write into our requested buffer.
+            // FIX read remote chars
+            // uint8_t rsp[MAX(len, 512)];
+            // FIX improve att_read_req to write into our requested buffer.
             // return att_read_req(conn_handle, self->handle, rsp);
-            return 0; //FIX
+            return 0; // FIX
         } else {
             mp_buffer_info_t bufinfo;
             if (!mp_get_buffer(self->value, &bufinfo, MP_BUFFER_READ)) {
@@ -113,13 +113,13 @@ void common_hal_bleio_characteristic_set_value(bleio_characteristic_obj_t *self,
     // Do GATT operations only if this characteristic has been added to a registered service.
     if (self->handle != BLE_GATT_HANDLE_INVALID) {
         if (common_hal_bleio_service_get_is_remote(self->service)) {
-            //FIX uint16_t conn_handle = bleio_connection_get_conn_handle(self->service->connection);
+            // FIX uint16_t conn_handle = bleio_connection_get_conn_handle(self->service->connection);
             if (self->props & CHAR_PROP_WRITE) {
-                //FIX writing remote chars
-                //uint8_t rsp[sizeof(bt_att_error_rsp)];
-                //att_write_req(conn_handle, self->handle, bufinfo->buf, bufinfo->len, rsp);
+                // FIX writing remote chars
+                // uint8_t rsp[sizeof(bt_att_error_rsp)];
+                // att_write_req(conn_handle, self->handle, bufinfo->buf, bufinfo->len, rsp);
             } else if (self->props & CHAR_PROP_WRITE_NO_RESPONSE) {
-                //att_write_cmd(conn_handle, self->handle, bufinfo->buff, bufinfo->len);
+                // att_write_cmd(conn_handle, self->handle, bufinfo->buff, bufinfo->len);
             } else {
                 mp_raise_bleio_BluetoothError(translate("Characteristic not writable"));
             }
@@ -172,7 +172,7 @@ void common_hal_bleio_characteristic_add_descriptor(bleio_characteristic_obj_t *
     self->service->end_handle = descriptor->handle;
 
     mp_obj_list_append(MP_OBJ_FROM_PTR(self->descriptor_list),
-                       MP_OBJ_FROM_PTR(descriptor));
+        MP_OBJ_FROM_PTR(descriptor));
 }
 
 void common_hal_bleio_characteristic_set_cccd(bleio_characteristic_obj_t *self, bool notify, bool indicate) {
@@ -191,8 +191,8 @@ void common_hal_bleio_characteristic_set_cccd(bleio_characteristic_obj_t *self,
         (notify ? CCCD_NOTIFY : 0) |
         (indicate ? CCCD_INDICATE : 0);
 
-    //FIX do remote
-    (void) cccd_value;
+    // FIX do remote
+    (void)cccd_value;
     // uint8_t rsp[sizeof(bt_att_error_rsp)];
     // if (att_write_req(conn_handle, self->cccd->handle, &cccd_value, sizeof(cccd_value)) == 0) {
     //     mp_raise_bleio_BluetoothError(translate("Could not write CCCD"));

devices/ble_hci/common-hal/_bleio/CharacteristicBuffer.c

@@ -47,9 +47,9 @@ void bleio_characteristic_buffer_update(bleio_characteristic_buffer_obj_t *self,
 
 // Assumes that timeout and buffer_size have been validated before call.
 void common_hal_bleio_characteristic_buffer_construct(bleio_characteristic_buffer_obj_t *self,
-                                                      bleio_characteristic_obj_t *characteristic,
-                                                      mp_float_t timeout,
-                                                      size_t buffer_size) {
+    bleio_characteristic_obj_t *characteristic,
+    mp_float_t timeout,
+    size_t buffer_size) {
 
     self->characteristic = characteristic;
     self->timeout_ms = timeout * 1000;
@@ -64,10 +64,10 @@ uint32_t common_hal_bleio_characteristic_buffer_read(bleio_characteristic_buffer
     uint64_t start_ticks = supervisor_ticks_ms64();
 
     // Wait for all bytes received or timeout
-    while ( (ringbuf_num_filled(&self->ringbuf) < len) && (supervisor_ticks_ms64() - start_ticks < self->timeout_ms) ) {
+    while ((ringbuf_num_filled(&self->ringbuf) < len) && (supervisor_ticks_ms64() - start_ticks < self->timeout_ms)) {
         RUN_BACKGROUND_TASKS;
         // Allow user to break out of a timeout with a KeyboardInterrupt.
-        if ( mp_hal_is_interrupted() ) {
+        if (mp_hal_is_interrupted()) {
             return 0;
         }
     }
@@ -97,8 +97,8 @@ void common_hal_bleio_characteristic_buffer_deinit(bleio_characteristic_buffer_o
 
 bool common_hal_bleio_characteristic_buffer_connected(bleio_characteristic_buffer_obj_t *self) {
     return self->characteristic != NULL &&
-        self->characteristic->service != NULL &&
-        (!self->characteristic->service->is_remote ||
-         (self->characteristic->service->connection != MP_OBJ_NULL &&
-          common_hal_bleio_connection_get_connected(self->characteristic->service->connection)));
+           self->characteristic->service != NULL &&
+           (!self->characteristic->service->is_remote ||
+               (self->characteristic->service->connection != MP_OBJ_NULL &&
+                   common_hal_bleio_connection_get_connected(self->characteristic->service->connection)));
 }

devices/ble_hci/common-hal/_bleio/Connection.c

@@ -73,8 +73,8 @@
 static volatile bool m_discovery_in_process;
 static volatile bool m_discovery_successful;
 
-//FIX static bleio_service_obj_t *m_char_discovery_service;
-//FIX static bleio_characteristic_obj_t *m_desc_discovery_characteristic;
+// FIX static bleio_service_obj_t *m_char_discovery_service;
+// FIX static bleio_characteristic_obj_t *m_desc_discovery_characteristic;
 
 // bool connection_on_ble_evt(ble_evt_t *ble_evt, void *self_in) {
 //     bleio_connection_internal_t *self = (bleio_connection_internal_t*)self_in;
@@ -326,7 +326,7 @@ void bleio_connection_clear(bleio_connection_internal_t *self) {
     self->conn_handle = BLE_CONN_HANDLE_INVALID;
     self->pair_status = PAIR_NOT_PAIRED;
     self->is_central = false;
-    //FIX bonding_clear_keys(&self->bonding_keys);
+    // FIX bonding_clear_keys(&self->bonding_keys);
 }
 
 bool common_hal_bleio_connection_get_paired(bleio_connection_obj_t *self) {
@@ -350,22 +350,22 @@ void common_hal_bleio_connection_disconnect(bleio_connection_internal_t *self) {
 void common_hal_bleio_connection_pair(bleio_connection_internal_t *self, bool bond) {
     self->pair_status = PAIR_WAITING;
 
-    //FIX check_nrf_error(sd_ble_gap_authenticate(self->conn_handle, &pairing_sec_params));
+    // FIX check_nrf_error(sd_ble_gap_authenticate(self->conn_handle, &pairing_sec_params));
 
     while (self->pair_status == PAIR_WAITING && !mp_hal_is_interrupted()) {
         RUN_BACKGROUND_TASKS;
     }
     if (mp_hal_is_interrupted()) {
         return;
     }
-    //FIX    check_sec_status(self->sec_status);
+    // FIX    check_sec_status(self->sec_status);
 }
 
 mp_float_t common_hal_bleio_connection_get_connection_interval(bleio_connection_internal_t *self) {
     while (self->conn_params_updating && !mp_hal_is_interrupted()) {
         RUN_BACKGROUND_TASKS;
     }
-    //FIX return 1.25f * self->conn_params.min_conn_interval;
+    // FIX return 1.25f * self->conn_params.min_conn_interval;
     return 0.0f;
 }
 
@@ -729,14 +729,14 @@ void common_hal_bleio_connection_set_connection_interval(bleio_connection_intern
 // }
 
 mp_obj_tuple_t *common_hal_bleio_connection_discover_remote_services(bleio_connection_obj_t *self, mp_obj_t service_uuids_whitelist) {
-    //FIX discover_remote_services(self->connection, service_uuids_whitelist);
+    // FIX discover_remote_services(self->connection, service_uuids_whitelist);
     bleio_connection_ensure_connected(self);
     // Convert to a tuple and then clear the list so the callee will take ownership.
-     mp_obj_tuple_t *services_tuple =
-         mp_obj_new_tuple(self->connection->remote_service_list->len,
-                          self->connection->remote_service_list->items);
-     mp_obj_list_clear(MP_OBJ_FROM_PTR(self->connection->remote_service_list));
-     return services_tuple;
+    mp_obj_tuple_t *services_tuple =
+        mp_obj_new_tuple(self->connection->remote_service_list->len,
+            self->connection->remote_service_list->items);
+    mp_obj_list_clear(MP_OBJ_FROM_PTR(self->connection->remote_service_list));
+    return services_tuple;
 }
 
 uint16_t bleio_connection_get_conn_handle(bleio_connection_obj_t *self) {
@@ -746,7 +746,7 @@ uint16_t bleio_connection_get_conn_handle(bleio_connection_obj_t *self) {
     return self->connection->conn_handle;
 }
 
-mp_obj_t bleio_connection_new_from_internal(bleio_connection_internal_t* internal) {
+mp_obj_t bleio_connection_new_from_internal(bleio_connection_internal_t *internal) {
     if (internal->connection_obj != mp_const_none) {
         return internal->connection_obj;
     }