resolve merge conflicts

Author: kukushking

awswrangler/_utils.py

@@ -121,8 +121,7 @@ def inner(*args: Any, **kwargs: Any) -> Any:
                 package_name = INSTALL_MAPPING.get(name)
                 install_name = package_name if package_name is not None else name
                 raise ModuleNotFoundError(
-                    f"Missing optional dependency '{name}'. "
-                    f"Use pip install awswrangler[{install_name}] to install it."
+                    f"Missing optional dependency '{name}'. Use pip install awswrangler[{install_name}] to install it."
                 )
             return func(*args, **kwargs)
 

awswrangler/athena/_read.py

@@ -610,7 +610,7 @@ def _unload(
     if partitioned_by:
         unload_parameters += f"  , partitioned_by=ARRAY{partitioned_by}"
 
-    sql = f"UNLOAD ({sql}) " f"TO '{path}' " f"WITH ({unload_parameters})"
+    sql = f"UNLOAD ({sql}) TO '{path}' WITH ({unload_parameters})"
     _logger.debug("Executing unload query: %s", sql)
     try:
         query_id: str = _start_query_execution(

awswrangler/athena/_utils.py

@@ -1025,13 +1025,13 @@ def parse_properties(parameters: dict[str, str]) -> str:
 
         query_parts += [
             """ROW FORMAT SERDE """,
-            f"""  '{table_detail['StorageDescriptor']['SerdeInfo']['SerializationLibrary']}' """,
+            f"""  '{table_detail["StorageDescriptor"]["SerdeInfo"]["SerializationLibrary"]}' """,
             """STORED AS INPUTFORMAT """,
-            f"""  '{table_detail['StorageDescriptor']['InputFormat']}' """,
+            f"""  '{table_detail["StorageDescriptor"]["InputFormat"]}' """,
             """OUTPUTFORMAT """,
-            f"""  '{table_detail['StorageDescriptor']['OutputFormat']}'""",
+            f"""  '{table_detail["StorageDescriptor"]["OutputFormat"]}'""",
             """LOCATION""",
-            f"""  '{table_detail['StorageDescriptor']['Location']}'""",
+            f"""  '{table_detail["StorageDescriptor"]["Location"]}'""",
             f"""TBLPROPERTIES (\n{tblproperties})""",
         ]
         sql = "\n".join(query_parts)

awswrangler/athena/_write_iceberg.py

@@ -309,7 +309,7 @@ def _merge_iceberg(
     if merge_cols:
         if merge_condition == "update":
             match_condition = f"""WHEN MATCHED THEN
-                UPDATE SET {', '.join([f'"{x}" = source."{x}"' for x in df.columns])}"""
+                UPDATE SET {", ".join([f'"{x}" = source."{x}"' for x in df.columns])}"""
         else:
             match_condition = ""
 
@@ -321,16 +321,16 @@ def _merge_iceberg(
         sql_statement = f"""
             MERGE INTO "{database}"."{table}" target
             USING "{database}"."{source_table}" source
-            ON {' AND '.join(merge_conditions)}
+            ON {" AND ".join(merge_conditions)}
             {match_condition}
             WHEN NOT MATCHED THEN
-                INSERT ({', '.join([f'"{x}"' for x in df.columns])})
-                VALUES ({', '.join([f'source."{x}"' for x in df.columns])})
+                INSERT ({", ".join([f'"{x}"' for x in df.columns])})
+                VALUES ({", ".join([f'source."{x}"' for x in df.columns])})
         """
     else:
         sql_statement = f"""
-        INSERT INTO "{database}"."{table}" ({', '.join([f'"{x}"' for x in df.columns])})
-        SELECT {', '.join([f'"{x}"' for x in df.columns])}
+        INSERT INTO "{database}"."{table}" ({", ".join([f'"{x}"' for x in df.columns])})
+        SELECT {", ".join([f'"{x}"' for x in df.columns])}
           FROM "{database}"."{source_table}"
         """
 
@@ -763,7 +763,7 @@ def delete_from_iceberg_table(
         sql_statement = f"""
             MERGE INTO "{database}"."{table}" target
             USING "{database}"."{temp_table}" source
-            ON {' AND '.join([f'target."{x}" = source."{x}"' for x in merge_cols])}
+            ON {" AND ".join([f'target."{x}" = source."{x}"' for x in merge_cols])}
             WHEN MATCHED THEN
                 DELETE
         """

awswrangler/dynamodb/_utils.py

@@ -253,7 +253,7 @@ def _remove_dup_pkeys_request_if_any(
             if self._extract_pkey_values(item, overwrite_by_pkeys) == pkey_values_new:
                 self._items_buffer.remove(item)
                 _logger.debug(
-                    "With overwrite_by_pkeys enabled, skipping " "request:%s",
+                    "With overwrite_by_pkeys enabled, skipping request:%s",
                     item,
                 )
 

awswrangler/oracle.py

@@ -48,8 +48,8 @@ def _validate_connection(con: "oracledb.Connection") -> None:
 
 
 def _get_table_identifier(schema: str | None, table: str) -> str:
-    schema_str = f'{identifier(schema, sql_mode="ansi")}.' if schema else ""
-    table_identifier = f'{schema_str}{identifier(table, sql_mode="ansi")}'
+    schema_str = f"{identifier(schema, sql_mode='ansi')}." if schema else ""
+    table_identifier = f"{schema_str}{identifier(table, sql_mode='ansi')}"
     return table_identifier
 
 
@@ -104,10 +104,10 @@ def _create_table(
         varchar_lengths=varchar_lengths,
         converter_func=_data_types.pyarrow2oracle,
     )
-    cols_str: str = "".join([f'{identifier(k, sql_mode="ansi")} {v},\n' for k, v in oracle_types.items()])[:-2]
+    cols_str: str = "".join([f"{identifier(k, sql_mode='ansi')} {v},\n" for k, v in oracle_types.items()])[:-2]
 
     if primary_keys:
-        primary_keys_str = ", ".join([f'{identifier(k, sql_mode="ansi")}' for k in primary_keys])
+        primary_keys_str = ", ".join([f"{identifier(k, sql_mode='ansi')}" for k in primary_keys])
     else:
         primary_keys_str = None
 
@@ -469,17 +469,17 @@ def _generate_upsert_statement(
 
     non_primary_key_columns = [key for key in df.columns if key not in set(primary_keys)]
 
-    primary_keys_str = ", ".join([f'{identifier(key, sql_mode="ansi")}' for key in primary_keys])
-    columns_str = ", ".join([f'{identifier(key, sql_mode="ansi")}' for key in non_primary_key_columns])
+    primary_keys_str = ", ".join([f"{identifier(key, sql_mode='ansi')}" for key in primary_keys])
+    columns_str = ", ".join([f"{identifier(key, sql_mode='ansi')}" for key in non_primary_key_columns])
 
     column_placeholders: str = f"({', '.join([':' + str(i + 1) for i in range(len(df.columns))])})"
 
     primary_key_condition_str = " AND ".join(
-        [f'{identifier(key, sql_mode="ansi")} = :{i+1}' for i, key in enumerate(primary_keys)]
+        [f"{identifier(key, sql_mode='ansi')} = :{i + 1}" for i, key in enumerate(primary_keys)]
     )
     assignment_str = ", ".join(
         [
-            f'{identifier(col, sql_mode="ansi")} = :{i + len(primary_keys) + 1}'
+            f"{identifier(col, sql_mode='ansi')} = :{i + len(primary_keys) + 1}"
             for i, col in enumerate(non_primary_key_columns)
         ]
     )

awswrangler/redshift/_utils.py

@@ -73,7 +73,7 @@ def _begin_transaction(cursor: "redshift_connector.Cursor") -> None:
 def _drop_table(cursor: "redshift_connector.Cursor", schema: str | None, table: str, cascade: bool = False) -> None:
     schema_str = f'"{schema}".' if schema else ""
     cascade_str = " CASCADE" if cascade else ""
-    sql = f'DROP TABLE IF EXISTS {schema_str}"{table}"' f"{cascade_str}"
+    sql = f'DROP TABLE IF EXISTS {schema_str}"{table}"{cascade_str}'
     _logger.debug("Executing drop table query:\n%s", sql)
     cursor.execute(sql)
 
@@ -130,10 +130,7 @@ def _add_table_columns(
 def _does_table_exist(cursor: "redshift_connector.Cursor", schema: str | None, table: str) -> bool:
     schema_str = f"TABLE_SCHEMA = '{schema}' AND" if schema else ""
     sql = (
-        f"SELECT true WHERE EXISTS ("
-        f"SELECT * FROM INFORMATION_SCHEMA.TABLES WHERE "
-        f"{schema_str} TABLE_NAME = '{table}'"
-        f");"
+        f"SELECT true WHERE EXISTS (SELECT * FROM INFORMATION_SCHEMA.TABLES WHERE {schema_str} TABLE_NAME = '{table}');"
     )
     _logger.debug("Executing select query:\n%s", sql)
     cursor.execute(sql)
@@ -236,12 +233,12 @@ def _validate_parameters(
     if sortkey:
         if not isinstance(sortkey, list):
             raise exceptions.InvalidRedshiftSortkey(
-                f"sortkey must be a List of items in the columns list: {cols}. " f"Currently value: {sortkey}"
+                f"sortkey must be a List of items in the columns list: {cols}. Currently value: {sortkey}"
             )
         for key in sortkey:
             if key not in cols:
                 raise exceptions.InvalidRedshiftSortkey(
-                    f"sortkey must be a List of items in the columns list: {cols}. " f"Currently value: {key}"
+                    f"sortkey must be a List of items in the columns list: {cols}. Currently value: {key}"
                 )
     if primary_keys:
         if not isinstance(primary_keys, list):

awswrangler/sqlserver.py

@@ -536,8 +536,7 @@ def to_sql(
                     sql = f"MERGE INTO {table_identifier}\nUSING (VALUES {placeholders}) AS source ({quoted_columns})\n"
                     sql += f"ON {' AND '.join(f'{table_identifier}.{col}=source.{col}' for col in merge_on_columns)}\n"
                     sql += (
-                        f"WHEN MATCHED THEN\n UPDATE "
-                        f"SET {', '.join(f'{col}=source.{col}' for col in column_names)}\n"
+                        f"WHEN MATCHED THEN\n UPDATE SET {', '.join(f'{col}=source.{col}' for col in column_names)}\n"
                     )
                     sql += (
                         f"WHEN NOT MATCHED THEN\n INSERT "

awswrangler/timestream/_read.py

@@ -409,7 +409,7 @@ def unload_to_files(
     timestream_client = _utils.client(service_name="timestream-query", session=boto3_session)
 
     partitioned_by_str: str = (
-        f"""partitioned_by = ARRAY [{','.join([f"'{col}'" for col in partition_cols])}],\n"""
+        f"""partitioned_by = ARRAY [{",".join([f"'{col}'" for col in partition_cols])}],\n"""
         if partition_cols is not None
         else ""
     )