Reformat Python part with black formatter (Ericsson#780)

.github/workflows/actions.yml

@@ -72,36 +72,50 @@ jobs:
             artifacts_dir: "ecchronos-binary/target"
     steps:
       - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+
       - name: Cache local Maven repository
         uses: actions/cache@13aacd865c20de90d75de3b17ebe84f7a17d57d2 # v4.0.0
         with:
           path: ~/.m2/repository
           key: build-${{ runner.os }}-maven-${{ hashFiles('**/pom.xml') }}
           restore-keys: |
             build-${{ runner.os }}-maven-
+
       - name: Set up JDK ${{ matrix.java_version }}
         uses: actions/setup-java@387ac29b308b003ca37ba93a6cab5eb57c8f5f93 # v4.0.0
         with:
           java-version: ${{ matrix.java_version }}
           distribution: 'temurin'
+
       - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+
       - name: Set up Python 3
         uses: actions/setup-python@0a5c61591373683505ea898e09a3ea4f39ef2b9c # v5.0.0
         with:
           python-version: 3
+
+      - name: Install black
+        run: python -m pip install black==24.10.0
+
+      - name: Run black in the check mode
+        run: black --check --verbose --line-length 120 ./ecchronos-binary/src
+
       - name: install dependencies
         run: mvn install -DskipTests=true
+
       - run: mvn $TEST_SUITE -B
         id: tests
         env:
           TEST_SUITE: ${{ matrix.test_suite }}
+
       - name: Upload artifacts
         if: ${{ failure() && steps.tests.conclusion == 'failure' }}
         uses: actions/upload-artifact@a8a3f3ad30e3422c9c7b888a15615d19a852ae32 # v3.1.3
         with:
           name: ${{ matrix.name }}-cassandra-logs
           path: ${{ matrix.artifacts_dir }}/cassandra*.log
           if-no-files-found: 'ignore'
+
       - name: Upload coverage to Codecov
         uses: codecov/codecov-action@54bcd8715eee62d40e33596ef5e8f0f48dbbccab # v4.1.0
         with:

ecchronos-binary/src/conf.py

@@ -14,11 +14,11 @@
 # limitations under the License.
 #
 
-project = 'ecChronos'
-copyright = '2023, Telefonaktiebolaget LM Ericsson'
-author = 'masokol'
+project = "ecChronos"
+copyright = "2023, Telefonaktiebolaget LM Ericsson"
+author = "masokol"
 
-extensions = ['sphinxcontrib.autoprogram', 'sphinx_markdown_builder']
+extensions = ["sphinxcontrib.autoprogram", "sphinx_markdown_builder"]
 
-templates_path = ['_templates']
+templates_path = ["_templates"]
 exclude_patterns = []

ecchronos-binary/src/pylib/ecchronoslib/rest.py

@@ -19,7 +19,7 @@
     from urllib.parse import quote
 except ImportError:
     from urllib2 import urlopen, Request, HTTPError, URLError
-    from urllib import quote # pylint: disable=ungrouped-imports
+    from urllib import quote  # pylint: disable=ungrouped-imports
 import json
 import os
 import ssl
@@ -51,15 +51,14 @@ def is_successful(self):
         return self.status_code == 200
 
     def transform_with_data(self, new_data):
-        return RequestResult(status_code=self.status_code,
-                             data=new_data,
-                             exception=self.exception,
-                             message=self.message)
+        return RequestResult(
+            status_code=self.status_code, data=new_data, exception=self.exception, message=self.message
+        )
 
 
 class RestRequest(object):
-    default_base_url = 'http://localhost:8080'
-    default_https_base_url = 'https://localhost:8080'
+    default_base_url = "http://localhost:8080"
+    default_https_base_url = "https://localhost:8080"
 
     def __init__(self, base_url=None):
         if base_url:
@@ -78,9 +77,9 @@ def get_param(httpmessage, param):
 
     @staticmethod
     def get_charset(response):
-        return RestRequest.get_param(response.info(), 'charset') or 'utf-8'
+        return RestRequest.get_param(response.info(), "charset") or "utf-8"
 
-    def request(self, url, method='GET'):
+    def request(self, url, method="GET"):
         request_url = "{0}/{1}".format(self.base_url, url)
         try:
             request = Request(request_url)
@@ -99,17 +98,15 @@ def request(self, url, method='GET'):
             response.close()
             return RequestResult(status_code=response.getcode(), data=json_data)
         except HTTPError as e:
-            return RequestResult(status_code=e.code,
-                                 message="Unable to retrieve resource {0}".format(request_url),
-                                 exception=e)
+            return RequestResult(
+                status_code=e.code, message="Unable to retrieve resource {0}".format(request_url), exception=e
+            )
         except URLError as e:
-            return RequestResult(status_code=404,
-                                 message="Unable to connect to {0}".format(request_url),
-                                 exception=e)
+            return RequestResult(status_code=404, message="Unable to connect to {0}".format(request_url), exception=e)
         except Exception as e:  # pylint: disable=broad-except
-            return RequestResult(exception=e,
-                                 message="Unable to retrieve resource {0}".format(request_url))
-    def basic_request(self, url, method='GET'):
+            return RequestResult(exception=e, message="Unable to retrieve resource {0}".format(request_url))
+
+    def basic_request(self, url, method="GET"):
         request_url = "{0}/{1}".format(self.base_url, url)
         try:
             request = Request(request_url)
@@ -127,38 +124,35 @@ def basic_request(self, url, method='GET'):
             data = response.read()
 
             response.close()
-            return data.decode('UTF-8')
+            return data.decode("UTF-8")
         except HTTPError as e:
-            return RequestResult(status_code=e.code,
-                                 message="Unable to retrieve resource {0}".format(request_url),
-                                 exception=e)
+            return RequestResult(
+                status_code=e.code, message="Unable to retrieve resource {0}".format(request_url), exception=e
+            )
         except URLError as e:
-            return RequestResult(status_code=404,
-                                 message="Unable to connect to {0}".format(request_url),
-                                 exception=e)
+            return RequestResult(status_code=404, message="Unable to connect to {0}".format(request_url), exception=e)
         except Exception as e:  # pylint: disable=broad-except
-            return RequestResult(exception=e,
-                                 message="Unable to retrieve resource {0}".format(request_url))
+            return RequestResult(exception=e, message="Unable to retrieve resource {0}".format(request_url))
 
 
 class V2RepairSchedulerRequest(RestRequest):
-    ROOT = 'repair-management/'
-    PROTOCOL = ROOT + 'v2/'
-    REPAIRS = PROTOCOL + 'repairs'
-    SCHEDULES = PROTOCOL + 'schedules'
+    ROOT = "repair-management/"
+    PROTOCOL = ROOT + "v2/"
+    REPAIRS = PROTOCOL + "repairs"
+    SCHEDULES = PROTOCOL + "schedules"
 
     v2_schedule_status_url = SCHEDULES
-    v2_schedule_id_status_url = SCHEDULES + '/{0}'
-    v2_schedule_id_full_status_url = SCHEDULES + '/{0}?full=true'
+    v2_schedule_id_status_url = SCHEDULES + "/{0}"
+    v2_schedule_id_full_status_url = SCHEDULES + "/{0}?full=true"
 
     v2_repair_status_url = REPAIRS
-    v2_repair_id_status_url = REPAIRS + '/{0}'
+    v2_repair_id_status_url = REPAIRS + "/{0}"
 
     v2_repair_run_url = REPAIRS
 
-    repair_info_url = PROTOCOL + 'repairInfo'
+    repair_info_url = PROTOCOL + "repairInfo"
 
-    running_job_url = PROTOCOL + 'running-job'
+    running_job_url = PROTOCOL + "running-job"
 
     def __init__(self, base_url=None):
         RestRequest.__init__(self, base_url)
@@ -234,13 +228,19 @@ def post(self, keyspace=None, table=None, local=False, repair_type="vnode"):
                 request_url += "&repairType=" + repair_type
             else:
                 request_url += "?repairType=" + repair_type
-        result = self.request(request_url, 'POST')
+        result = self.request(request_url, "POST")
         if result.is_successful():
             result = result.transform_with_data(new_data=[Repair(x) for x in result.data])
         return result
 
-    def get_repair_info(self, keyspace=None, table=None, since=None,  # pylint: disable=too-many-arguments, too-many-positional-arguments
-                        duration=None, local=False):
+    def get_repair_info(  # pylint: disable=too-many-arguments, too-many-positional-arguments
+        self,
+        keyspace=None,
+        table=None,
+        since=None,
+        duration=None,
+        local=False,
+    ):
         request_url = V2RepairSchedulerRequest.repair_info_url
         if keyspace:
             request_url += "?keyspace=" + quote(keyspace)

ecchronos-binary/src/pylib/ecchronoslib/table_printer.py

@@ -20,7 +20,7 @@
 
 def print_schedule(schedule, max_lines, full=False):
     if not schedule.is_valid():
-        print('Schedule not found')
+        print("Schedule not found")
         return
 
     verbose_print_format = "{0:15s}: {1}"
@@ -38,8 +38,9 @@ def print_schedule(schedule, max_lines, full=False):
     if full:
         vnode_state_table = [["Start token", "End token", "Replicas", "Repaired at", "Repaired"]]
 
-        sorted_vnode_states = sorted(schedule.vnode_states, key=lambda vnode: vnode.last_repaired_at_in_ms,
-                                     reverse=True)
+        sorted_vnode_states = sorted(
+            schedule.vnode_states, key=lambda vnode: vnode.last_repaired_at_in_ms, reverse=True
+        )
 
         if max_lines > -1:
             sorted_vnode_states = sorted_vnode_states[:max_lines]
@@ -51,50 +52,62 @@ def print_schedule(schedule, max_lines, full=False):
 
 
 def _add_vnode_state_to_table(vnode_state, table):
-    entry = [vnode_state.start_token, vnode_state.end_token, ', '.join(vnode_state.replicas),
-             vnode_state.get_last_repaired_at(), vnode_state.repaired]
+    entry = [
+        vnode_state.start_token,
+        vnode_state.end_token,
+        ", ".join(vnode_state.replicas),
+        vnode_state.get_last_repaired_at(),
+        vnode_state.repaired,
+    ]
 
     table.append(entry)
 
 
 def print_summary(schedules):
     status_list = [schedule.status for schedule in schedules]
     summary_format = "Summary: {0} completed, {1} on time, {2} blocked, {3} late, {4} overdue"
-    print(summary_format.format(status_list.count('COMPLETED'),
-                                status_list.count('ON_TIME'),
-                                status_list.count('BLOCKED'),
-                                status_list.count('LATE'),
-                                status_list.count('OVERDUE')))
+    print(
+        summary_format.format(
+            status_list.count("COMPLETED"),
+            status_list.count("ON_TIME"),
+            status_list.count("BLOCKED"),
+            status_list.count("LATE"),
+            status_list.count("OVERDUE"),
+        )
+    )
 
 
 def print_repair_summary(repairs):
     status_list = [repair.status for repair in repairs]
     summary_format = "Summary: {0} completed, {1} in queue, {2} blocked, {3} warning, {4} error"
-    print(summary_format.format(status_list.count('COMPLETED'),
-                                status_list.count('IN_QUEUE'),
-                                status_list.count('BLOCKED'),
-                                status_list.count('WARNING'),
-                                status_list.count('ERROR')))
+    print(
+        summary_format.format(
+            status_list.count("COMPLETED"),
+            status_list.count("IN_QUEUE"),
+            status_list.count("BLOCKED"),
+            status_list.count("WARNING"),
+            status_list.count("ERROR"),
+        )
+    )
 
 
 def print_schedules(schedules, max_lines):
-    schedule_table = [["Id", "Keyspace", "Table", "Status", "Repaired(%)",
-                       "Completed at", "Next repair", "Repair type"]]
+    schedule_table = [
+        ["Id", "Keyspace", "Table", "Status", "Repaired(%)", "Completed at", "Next repair", "Repair type"]
+    ]
     print("Snapshot as of", datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
     print_schedule_table(schedule_table, schedules, max_lines)
     print_summary(schedules)
 
 
 def print_repairs(repairs, max_lines=-1):
-    repair_table = [["Id", "Host Id", "Keyspace", "Table", "Status", "Repaired(%)",
-                     "Completed at", "Repair type"]]
+    repair_table = [["Id", "Host Id", "Keyspace", "Table", "Status", "Repaired(%)", "Completed at", "Repair type"]]
     print_repair_table(repair_table, repairs, max_lines)
     print_repair_summary(repairs)
 
 
 def print_schedule_table(schedule_table, schedules, max_lines):
-    sorted_schedules = sorted(schedules, key=lambda x: (x.last_repaired_at_in_ms, x.repaired_ratio),
-                              reverse=False)
+    sorted_schedules = sorted(schedules, key=lambda x: (x.last_repaired_at_in_ms, x.repaired_ratio), reverse=False)
     if max_lines > -1:
         sorted_schedules = sorted_schedules[:max_lines]
 
@@ -114,21 +127,38 @@ def print_repair_table(repair_table, repairs, max_lines):
 
 
 def print_repair(repair):
-    repair_table = [["Id", "Host Id", "Keyspace", "Table", "Status", "Repaired(%)",
-                     "Completed at", "Repair type"], _convert_repair(repair)]
+    repair_table = [
+        ["Id", "Host Id", "Keyspace", "Table", "Status", "Repaired(%)", "Completed at", "Repair type"],
+        _convert_repair(repair),
+    ]
     table_formatter.format_table(repair_table)
 
 
 def _convert_repair(repair):
-    entry = [repair.job_id, repair.host_id, repair.keyspace, repair.table, repair.status,
-             repair.get_repair_percentage(), repair.get_completed_at(), repair.repair_type]
+    entry = [
+        repair.job_id,
+        repair.host_id,
+        repair.keyspace,
+        repair.table,
+        repair.status,
+        repair.get_repair_percentage(),
+        repair.get_completed_at(),
+        repair.repair_type,
+    ]
     return entry
 
 
 def _convert_schedule(schedule):
-    entry = [schedule.job_id, schedule.keyspace, schedule.table, schedule.status,
-             schedule.get_repair_percentage(), schedule.get_last_repaired_at(), schedule.get_next_repair(),
-             schedule.repair_type]
+    entry = [
+        schedule.job_id,
+        schedule.keyspace,
+        schedule.table,
+        schedule.status,
+        schedule.get_repair_percentage(),
+        schedule.get_last_repaired_at(),
+        schedule.get_next_repair(),
+        schedule.repair_type,
+    ]
 
     return entry
 
@@ -139,8 +169,7 @@ def print_repair_info(repair_info, max_lines=-1):
 
 
 def print_repair_stats(repair_stats, max_lines=-1):
-    repair_stats_table = [["Keyspace", "Table", "Repaired (%)",
-                           "Repair time taken"]]
+    repair_stats_table = [["Keyspace", "Table", "Repaired (%)", "Repair time taken"]]
     sorted_repair_stats = sorted(repair_stats, key=lambda x: (x.repaired_ratio, x.keyspace, x.table), reverse=False)
     if max_lines > -1:
         sorted_repair_stats = sorted_repair_stats[:max_lines]
@@ -151,6 +180,10 @@ def print_repair_stats(repair_stats, max_lines=-1):
 
 
 def _convert_repair_stat(repair_stat):
-    entry = [repair_stat.keyspace, repair_stat.table, repair_stat.get_repaired_percentage(),
-             repair_stat.get_repair_time_taken()]
+    entry = [
+        repair_stat.keyspace,
+        repair_stat.table,
+        repair_stat.get_repaired_percentage(),
+        repair_stat.get_repair_time_taken(),
+    ]
     return entry