fix: Ruff formatting errors (#2306)

Author: LeonLuttenberger

awswrangler/_arrow.py

@@ -19,7 +19,7 @@ def _extract_partitions_from_path(path_root: str, path: str) -> Dict[str, str]:
         raise Exception(f"Object {path} is not under the root path ({path_root}).")
     path_wo_filename: str = path.rpartition("/")[0] + "/"
     path_wo_prefix: str = path_wo_filename.replace(f"{path_root}/", "")
-    dirs: Tuple[str, ...] = tuple(x for x in path_wo_prefix.split("/") if (x != "") and (x.count("=") > 0))
+    dirs: Tuple[str, ...] = tuple(x for x in path_wo_prefix.split("/") if x and (x.count("=") > 0))
     if not dirs:
         return {}
     values_tups = cast(Tuple[Tuple[str, str]], tuple(tuple(x.split("=", maxsplit=1)[:2]) for x in dirs))

awswrangler/_data_types.py

@@ -342,9 +342,7 @@ def athena2pyarrow(dtype: str) -> pa.DataType:  # pylint: disable=too-many-retur
     raise exceptions.UnsupportedType(f"Unsupported Athena type: {dtype}")
 
 
-def athena2pandas(
-    dtype: str, dtype_backend: Optional[str] = None
-) -> str:  # pylint: disable=too-many-branches,too-many-return-statements
+def athena2pandas(dtype: str, dtype_backend: Optional[str] = None) -> str:  # pylint: disable=too-many-return-statements
     """Athena to Pandas data types conversion."""
     dtype = dtype.lower()
     if dtype == "tinyint":
@@ -493,24 +491,24 @@ def pyarrow_types_from_pandas(  # pylint: disable=too-many-branches,too-many-sta
     cols: List[str] = []
     cols_dtypes: Dict[str, Optional[pa.DataType]] = {}
     for name, dtype in df.dtypes.to_dict().items():
-        dtype = str(dtype)
+        dtype_str = str(dtype)
         if name in ignore_cols:
             cols_dtypes[name] = None
-        elif dtype == "Int8":
+        elif dtype_str == "Int8":
             cols_dtypes[name] = pa.int8()
-        elif dtype == "Int16":
+        elif dtype_str == "Int16":
             cols_dtypes[name] = pa.int16()
-        elif dtype == "Int32":
+        elif dtype_str == "Int32":
             cols_dtypes[name] = pa.int32()
-        elif dtype == "Int64":
+        elif dtype_str == "Int64":
             cols_dtypes[name] = pa.int64()
-        elif dtype == "float32":
+        elif dtype_str == "float32":
             cols_dtypes[name] = pa.float32()
-        elif dtype == "float64":
+        elif dtype_str == "float64":
             cols_dtypes[name] = pa.float64()
-        elif dtype == "string":
+        elif dtype_str == "string":
             cols_dtypes[name] = pa.string()
-        elif dtype == "boolean":
+        elif dtype_str == "boolean":
             cols_dtypes[name] = pa.bool_()
         else:
             cols.append(name)

awswrangler/_databases.py

@@ -160,7 +160,7 @@ def _records2df(
     for col_values, col_name in zip(tuple(zip(*records)), cols_names):  # Transposing
         if (dtype is None) or (col_name not in dtype):
             if _oracledb_found:
-                col_values = oracle.handle_oracle_objects(col_values, col_name)
+                col_values = oracle.handle_oracle_objects(col_values, col_name)  # ruff: noqa: PLW2901
             try:
                 array: pa.Array = pa.array(obj=col_values, safe=safe)  # Creating Arrow array
             except pa.ArrowInvalid as ex:

awswrangler/athena/_read.py

@@ -40,7 +40,7 @@ def _extract_ctas_manifest_paths(path: str, boto3_session: Optional[boto3.Sessio
     bucket_name, key_path = _utils.parse_path(path)
     client_s3 = _utils.client(service_name="s3", session=boto3_session)
     body: bytes = client_s3.get_object(Bucket=bucket_name, Key=key_path)["Body"].read()
-    paths = [x for x in body.decode("utf-8").split("\n") if x != ""]
+    paths = [x for x in body.decode("utf-8").split("\n") if x]
     _logger.debug("Read %d paths from manifest file in: %s", len(paths), path)
     return paths
 
@@ -58,7 +58,7 @@ def _add_query_metadata_generator(
 ) -> Iterator[pd.DataFrame]:
     """Add Query Execution metadata to every DF in iterator."""
     for df in dfs:
-        df = _apply_query_metadata(df=df, query_metadata=query_metadata)
+        df = _apply_query_metadata(df=df, query_metadata=query_metadata)  # ruff: noqa: PLW2901
         yield df
 
 

awswrangler/athena/_utils.py

@@ -97,11 +97,10 @@ def _start_query_execution(
             args["ResultConfiguration"]["EncryptionConfiguration"] = {"EncryptionOption": wg_config.encryption}
             if wg_config.kms_key is not None:
                 args["ResultConfiguration"]["EncryptionConfiguration"]["KmsKey"] = wg_config.kms_key
-    else:
-        if encryption is not None:
-            args["ResultConfiguration"]["EncryptionConfiguration"] = {"EncryptionOption": encryption}
-            if kms_key is not None:
-                args["ResultConfiguration"]["EncryptionConfiguration"]["KmsKey"] = kms_key
+    elif encryption is not None:
+        args["ResultConfiguration"]["EncryptionConfiguration"] = {"EncryptionOption": encryption}
+        if kms_key is not None:
+            args["ResultConfiguration"]["EncryptionConfiguration"]["KmsKey"] = kms_key
 
     # database
     if database is not None:
@@ -187,8 +186,8 @@ def _parse_describe_table(df: pd.DataFrame) -> pd.DataFrame:
     origin_df_dict = df.to_dict()
     target_df_dict: Dict[str, List[Union[str, bool]]] = {"Column Name": [], "Type": [], "Partition": [], "Comment": []}
     for index, col_name in origin_df_dict["col_name"].items():
-        col_name = col_name.strip()
-        if col_name.startswith("#") or col_name == "":
+        col_name = col_name.strip()  # ruff: noqa: PLW2901
+        if col_name.startswith("#") or not col_name:
             pass
         elif col_name in target_df_dict["Column Name"]:
             index_col_name = target_df_dict["Column Name"].index(col_name)

awswrangler/data_api/_connector.py

@@ -107,7 +107,9 @@ def _get_statement_result(self, request_id: str) -> pd.DataFrame:
         pass
 
     @staticmethod
-    def _get_column_value(column_value: Dict[str, Any], col_type: Optional[str] = None) -> Any:
+    def _get_column_value(  # pylint: disable=too-many-return-statements
+        column_value: Dict[str, Any], col_type: Optional[str] = None
+    ) -> Any:
         """Return the first non-null key value for a given dictionary.
 
         The key names for a given record depend on the column type: stringValue, longValue, etc.

awswrangler/data_api/rds.py

@@ -313,7 +313,9 @@ def _create_table(
     con.execute(sql, database=database, transaction_id=transaction_id)
 
 
-def _create_value_dict(value: Any) -> Tuple[Dict[str, Any], Optional[str]]:
+def _create_value_dict(  # pylint: disable=too-many-return-statements
+    value: Any,
+) -> Tuple[Dict[str, Any], Optional[str]]:
     if value is None or pd.isnull(value):
         return {"isNull": True}, None
 
@@ -351,7 +353,7 @@ def _generate_parameters(columns: List[str], values: List[Any]) -> List[Dict[str
     parameter_list = []
 
     for col, value in zip(columns, values):
-        value, type_hint = _create_value_dict(value)
+        value, type_hint = _create_value_dict(value)  # ruff: noqa: PLW2901
 
         parameter = {
             "name": col,

awswrangler/data_api/redshift.py

@@ -87,13 +87,13 @@ def rollback_transaction(self, transaction_id: str) -> str:
         raise NotImplementedError("Redshift Data API does not support transactions.")
 
     def _validate_redshift_target(self) -> None:
-        if self.database == "":
+        if not self.database:
             raise ValueError("`database` must be set for connection")
-        if self.cluster_id == "" and self.workgroup_name == "":
+        if not self.cluster_id and not self.workgroup_name:
             raise ValueError("Either `cluster_id` or `workgroup_name`(Redshift Serverless) must be set for connection")
 
     def _validate_auth_method(self) -> None:
-        if self.workgroup_name == "" and self.secret_arn == "" and self.db_user == "":
+        if not self.workgroup_name and not self.secret_arn and not self.db_user:
             raise ValueError("Either `secret_arn` or `db_user` must be set for authentication")
 
     def _execute_statement(

awswrangler/dynamodb/_utils.py

@@ -165,19 +165,17 @@ def _serialize_kwargs(kwargs: Dict[str, Any]) -> Dict[str, Any]:
 
     if "ExpressionAttributeNames" in kwargs:
         kwargs["ExpressionAttributeNames"].update(names)
-    else:
-        if names:
-            kwargs["ExpressionAttributeNames"] = names
+    elif names:
+        kwargs["ExpressionAttributeNames"] = names
 
     values = {k: serializer.serialize(v) for k, v in values.items()}
     if "ExpressionAttributeValues" in kwargs:
         kwargs["ExpressionAttributeValues"] = {
             k: serializer.serialize(v) for k, v in kwargs["ExpressionAttributeValues"].items()
         }
         kwargs["ExpressionAttributeValues"].update(values)
-    else:
-        if values:
-            kwargs["ExpressionAttributeValues"] = values
+    elif values:
+        kwargs["ExpressionAttributeValues"] = values
 
     return kwargs
 

awswrangler/neptune/_gremlin_parser.py

@@ -68,7 +68,7 @@ def _parse_dict(data: Any) -> Any:
         for k, v in data.items():
             # If the key is a Vertex or an Edge do special processing
             if isinstance(k, (gremlin.Vertex, gremlin.Edge)):
-                k = k.id
+                k = k.id  # ruff: noqa: PLW2901
 
             # If the value is a list do special processing to make it a scalar if the list is of length 1
             if isinstance(v, list) and len(v) == 1: