feat: utilize all SIM rules

JIRA: TRIVIAL
risk: low

Author: hkad98

gooddata-dbt/gooddata_dbt/args.py

@@ -37,10 +37,7 @@ def set_gooddata_endpoint_args(parser: argparse.ArgumentParser) -> None:
     )
     # Alternative - use profile.yml file
     env_profiles = os.getenv("GOODDATA_PROFILES")
-    if env_profiles:
-        env_profiles_list = env_profiles.split(" ")
-    else:
-        env_profiles_list = []
+    env_profiles_list = env_profiles.split(" ") if env_profiles else []
     parser.add_argument(
         "-gp",
         "--gooddata-profiles",

gooddata-flight-server/gooddata_flight_server/errors/error_code.py

@@ -29,17 +29,15 @@ def _init_names(cls: Any) -> Any:
 
 
 _RetryFlagsLiteral: TypeAlias = Literal["any", "other", "here"]
+_FlagsMapping = {
+    Literal["any"]: _RETRY_ANY_FLAG,
+    Literal["here"]: _RETRY_HERE_FLAG,
+    Literal["other"]: _RETRY_OTHER_FLAG,
+}
 
 
 def _get_flags(retry: Optional[_RetryFlagsLiteral] = None) -> int:
-    if retry == "any":
-        return _RETRY_ANY_FLAG
-    elif retry == "here":
-        return _RETRY_HERE_FLAG
-    elif retry == "other":
-        return _RETRY_OTHER_FLAG
-
-    return 0x0
+    return _FlagsMapping.get(retry, 0x0)
 
 
 def _error_code(code: int, retry: Optional[_RetryFlagsLiteral] = None) -> int:

gooddata-flight-server/gooddata_flight_server/server/flight_rpc/flight_service.py

@@ -25,10 +25,7 @@
 
 
 def _get_flight_server_locations(config: ServerConfig) -> tuple[str, str]:
-    if config.use_tls:
-        transport = "grpc+tls"
-    else:
-        transport = "grpc"
+    transport = "grpc+tls" if config.use_tls else "grpc"
 
     return (
         f"{transport}://{config.listen_host}:{config.listen_port}",

gooddata-flight-server/gooddata_flight_server/tasks/thread_task_executor.py

@@ -500,23 +500,25 @@ def _task_run_wrapper(self, task_execution: _TaskExecution) -> Any:
         structlog.contextvars.clear_contextvars()
         structlog.contextvars.bind_contextvars(**logging_ctx)
 
-        with task_execution.use_execution_span():
-            with SERVER_TRACER.start_as_current_span("task_run", attributes={TaskAttributes.TaskId: task.task_id}):
-                self._logger.info(
-                    "task_run",
-                    task_id=task.task_id,
-                    waited=stats.run_waited_duration,
-                )
-                self._metrics.wait_time.observe(stats.run_waited_duration)
+        with (
+            task_execution.use_execution_span(),
+            SERVER_TRACER.start_as_current_span("task_run", attributes={TaskAttributes.TaskId: task.task_id}),
+        ):
+            self._logger.info(
+                "task_run",
+                task_id=task.task_id,
+                waited=stats.run_waited_duration,
+            )
+            self._metrics.wait_time.observe(stats.run_waited_duration)
 
-                try:
-                    return task.run()
-                finally:
-                    stats.run_completed = time.perf_counter()
-                    stats.completed = stats.run_completed
+            try:
+                return task.run()
+            finally:
+                stats.run_completed = time.perf_counter()
+                stats.completed = stats.run_completed
 
-                    self._metrics.task_duration.observe(stats.run_duration)
-                    self._metrics.task_e2e_duration.observe(stats.duration)
+                self._metrics.task_duration.observe(stats.run_duration)
+                self._metrics.task_e2e_duration.observe(stats.duration)
 
     def _finish_task_with_result(self, task_execution: "_TaskExecution", result: TaskExecutionResult) -> None:
         task = task_execution.task
@@ -534,11 +536,10 @@ def run_task(
         self,
         task_execution: _TaskExecution,
     ) -> Future:
-        with task_execution.use_execution_span():
-            with SERVER_TRACER.start_as_current_span("task_run_submit"):
-                task_execution.stats.run_submitted = time.perf_counter()
+        with task_execution.use_execution_span(), SERVER_TRACER.start_as_current_span("task_run_submit"):
+            task_execution.stats.run_submitted = time.perf_counter()
 
-                return self._executor.submit(self._task_run_wrapper, task_execution)
+            return self._executor.submit(self._task_run_wrapper, task_execution)
 
     def process_task_result(
         self,

gooddata-flight-server/tests/server/conftest.py

@@ -36,7 +36,7 @@ def _find_free_port():
 
 def _clean_env_vars():
     to_drop = []
-    for key in os.environ.keys():
+    for key in os.environ:
         if key.startswith("GOODDATA_FLIGHT"):
             to_drop.append(key)
 

gooddata-flight-server/tests/server/test_server.py

@@ -60,9 +60,8 @@ def test_smoke_with_auth_fail1(tls_ca_cert):
     os.environ["GOODDATA_FLIGHT_SERVER__AUTHENTICATION_METHOD"] = "token"
     os.environ["GOODDATA_FLIGHT_ENUMERATED_TOKENS__TOKENS"] = '["t1", "t2"]'
 
-    with server(_TestingMethods(), tls=True) as s:
-        with pytest.raises(pyarrow.flight.FlightUnauthenticatedError):
-            list(pyarrow.flight.FlightClient(s.location, tls_root_certs=tls_ca_cert).list_flights())
+    with server(_TestingMethods(), tls=True) as s, pytest.raises(pyarrow.flight.FlightUnauthenticatedError):
+        list(pyarrow.flight.FlightClient(s.location, tls_root_certs=tls_ca_cert).list_flights())
 
 
 def test_smoke_with_auth_fail2(tls_ca_cert):
@@ -71,9 +70,8 @@ def test_smoke_with_auth_fail2(tls_ca_cert):
 
     # important: header names must be lowercase
     opts = FlightCallOptions(headers=[(b"authorization", b"Bearer 123")])
-    with server(_TestingMethods(), tls=True) as s:
-        with pytest.raises(pyarrow.flight.FlightUnauthenticatedError):
-            list(pyarrow.flight.FlightClient(s.location, tls_root_certs=tls_ca_cert).list_flights(b"", opts))
+    with server(_TestingMethods(), tls=True) as s, pytest.raises(pyarrow.flight.FlightUnauthenticatedError):
+        list(pyarrow.flight.FlightClient(s.location, tls_root_certs=tls_ca_cert).list_flights(b"", opts))
 
 
 def test_smoke_with_auth1(tls_ca_cert):
@@ -107,10 +105,9 @@ def test_smoke_with_custom_auth_fail1(tls_ca_cert):
     os.environ["GOODDATA_FLIGHT_SERVER__TOKEN_VERIFICATION"] = "tests.server.testing_token_verifier"
 
     opts = FlightCallOptions(headers=[(b"x-some-bad-header", b"test_token")])
-    with server(_TestingMethods(), tls=True) as s:
-        with pytest.raises(pyarrow.flight.FlightUnauthenticatedError):
-            c = pyarrow.flight.FlightClient(s.location, tls_root_certs=tls_ca_cert)
-            tuple(c.list_flights(b"", opts))
+    with server(_TestingMethods(), tls=True) as s, pytest.raises(pyarrow.flight.FlightUnauthenticatedError):
+        c = pyarrow.flight.FlightClient(s.location, tls_root_certs=tls_ca_cert)
+        tuple(c.list_flights(b"", opts))
 
 
 def test_smoke_with_custom_auth_fail2(tls_ca_cert):
@@ -119,7 +116,6 @@ def test_smoke_with_custom_auth_fail2(tls_ca_cert):
     os.environ["GOODDATA_FLIGHT_SERVER__TOKEN_VERIFICATION"] = "tests.server.testing_token_verifier"
 
     opts = FlightCallOptions(headers=[(b"x-custom-token-header", b"invalid")])
-    with server(_TestingMethods(), tls=True) as s:
-        with pytest.raises(pyarrow.flight.FlightUnauthenticatedError):
-            c = pyarrow.flight.FlightClient(s.location, tls_root_certs=tls_ca_cert)
-            tuple(c.list_flights(b"", opts))
+    with server(_TestingMethods(), tls=True) as s, pytest.raises(pyarrow.flight.FlightUnauthenticatedError):
+        c = pyarrow.flight.FlightClient(s.location, tls_root_certs=tls_ca_cert)
+        tuple(c.list_flights(b"", opts))

gooddata-pandas/gooddata_pandas/data_access.py

@@ -119,10 +119,7 @@ def _process_index(self, index_by: Optional[IndexDef] = None) -> None:
         if index_by is None:
             return
 
-        if not isinstance(index_by, dict):
-            _index_by = {self._DEFAULT_INDEX_NAME: index_by}
-        else:
-            _index_by = index_by
+        _index_by = {self._DEFAULT_INDEX_NAME: index_by} if not isinstance(index_by, dict) else index_by
 
         for index_name, index_def in _index_by.items():
             if isinstance(index_def, str) and (index_def in self._col_to_attr_idx):
@@ -208,11 +205,14 @@ def _update_filter_ids(self, filter_by: Optional[Union[Filter, list[Filter]]] =
                         raise ValueError(f"AttributeFilter instance referencing metric [{_filter.label}]")
                     else:
                         _filter.label = _str_to_obj_id(_filter.label) or _filter.label
-                elif isinstance(_filter, MetricValueFilter) and isinstance(_filter.metric, str):
-                    if _filter.metric in self._col_to_metric_idx:
-                        # Metric is referenced by local_id which was already generated during creation of columns
-                        # When Metric filter contains ObjId reference, it does not need to be modified
-                        _filter.metric = self._metrics[self._col_to_metric_idx[_filter.metric]].local_id
+                elif (
+                    isinstance(_filter, MetricValueFilter)
+                    and isinstance(_filter.metric, str)
+                    and _filter.metric in self._col_to_metric_idx
+                ):
+                    # Metric is referenced by local_id which was already generated during creation of columns
+                    # When Metric filter contains ObjId reference, it does not need to be modified
+                    _filter.metric = self._metrics[self._col_to_metric_idx[_filter.metric]].local_id
 
         return filters
 

gooddata-pandas/gooddata_pandas/result_convertor.py

@@ -347,10 +347,7 @@ def _mapper(header: Any, header_idx: Optional[int]) -> Optional[str]:
             if "labelValue" in header["attributeHeader"]:
                 label_value = header["attributeHeader"]["labelValue"]
                 primary_label_value = header["attributeHeader"]["primaryLabelValue"]
-                if use_primary_labels_in_attributes:
-                    label = primary_label_value
-                else:
-                    label = label_value
+                label = primary_label_value if use_primary_labels_in_attributes else label_value
                 if header_idx is not None:
                     if header_idx in primary_attribute_labels_mapping:
                         primary_attribute_labels_mapping[header_idx][primary_label_value] = label_value

gooddata-sdk/gooddata_sdk/visualization.py

@@ -618,10 +618,7 @@ def get_bucket_of_type(self, bucket_type: BucketType) -> VisualizationBucket:
         return VisualizationBucket({"items": [], "localIdentifier": _BUCKET_TYPE_TO_LOCAL_ID[bucket_type]})
 
     def has_bucket_of_type(self, bucket_type: BucketType) -> bool:
-        for b in self.buckets:
-            if b.type == bucket_type:
-                return True
-        return False
+        return any(b.type == bucket_type for b in self.buckets)
 
     def has_row_and_col_totals(self) -> bool:
         row_bucket = self.get_bucket_of_type(BucketType.ROWS)

gooddata-sdk/tests/support/test_support.py

@@ -37,7 +37,7 @@ def test_wait_till_available_no_wait(test_config):
     sdk = GoodDataSdk.create(host_=test_config["host"], token_=test_config["token"])
     start_time = time.time()
     sdk.support.wait_till_available(3)
-    assert 1000 > (time.time() - start_time)
+    assert (time.time() - start_time) < 1000
 
 
 def test_wait_till_available_timeout(test_config):