Alternate quotes for strings inside f-strings in preview

[MichaReiser]

Summary

This PR changes how quotes are selected for f-strings and nested string literals when preview mode is on.

For the outer f-string: The logic is the same as for any other strings, except that we only count the quotes inside literal parts. This is different from before where choose_quotes analyzed the entire f-string, including expressions.

The rules for inner f-strings are:

• If the outer f-string is a triple quoted string: Prefer the configured quote style
• If the outer f-string is single quoted: Prefer the opposite quote style (alternate the quote styles).

f"{'inner'}"

# Before
f"{"inner"}"

The only exception to the above rule is when targeting <Py312 and the f-string contains a debug-expression that itself contains quotes:

f'{a + "b"=}' # Can't change the quotes here

In this case, changing the quotes is unsafe because the debug expression will retain its existing quotes. That's why the implementation must preserve the outer quotes as is. Changing the outer quotes is fine when targeting Py312+.

f"{a + "b"=}"

The advantage of limiting the pre-312 behavior to only debug expressions is that an upgrade of the target version to 312 should result in a very small diff considering that debug expressions containing quotes should be rare.

Fixes #13237
Fixes #11056

Considerations

This new style no longer optimizes for the fewest "foreign" quotes in total. E.g. it changes

return f'#{data["node"]["number"]} {component_str}{data["node"]["title"]}'

to

return f"#{data['node']['number']} {component_str}{data['node']['title']}"

where the total preferred quotes count is 2, but it uses 8 single quotes.

Test Plan

• Added tests
• Reviewed the snapshot changes
• Reviewed the ecosystem changes

Review

The most useful for review is if you can think of more cursed f-string examples where the above approach might produce invalid f-strings or weird looking quote selections.

[MichaReiser]

Both from_part and merge are also needed for implicit string formatting. We get good reuse :)

[github-actions]

ruff-ecosystem results

Linter (stable)

✅ ecosystem check detected no linter changes.

Linter (preview)

✅ ecosystem check detected no linter changes.

Formatter (stable)

✅ ecosystem check detected no format changes.

Formatter (preview)

ℹ️ ecosystem check detected format changes. (+338 -338 lines in 178 files in 30 projects; 24 projects unchanged)

DisnakeDev/disnake (+2 -2 lines across 1 file)

ruff format --preview

disnake/opus.py~L371

     def set_bandwidth(self, req: BAND_CTL) -> None:
         if req not in band_ctl:
             raise KeyError(
-                f'{req!r} is not a valid bandwidth setting. Try one of: {",".join(band_ctl)}'
+                f"{req!r} is not a valid bandwidth setting. Try one of: {','.join(band_ctl)}"
             )
 
         k = band_ctl[req]

disnake/opus.py~L380

     def set_signal_type(self, req: SIGNAL_CTL) -> None:
         if req not in signal_ctl:
             raise KeyError(
-                f'{req!r} is not a valid bandwidth setting. Try one of: {",".join(signal_ctl)}'
+                f"{req!r} is not a valid bandwidth setting. Try one of: {','.join(signal_ctl)}"
             )
 
         k = signal_ctl[req]

RasaHQ/rasa (+2 -2 lines across 1 file)

ruff format --preview

rasa/core/training/interactive.py~L346

     choices = []
     for p in sorted_intents:
         name_with_confidence = (
-            f'{p.get("confidence"):03.2f} {p.get(INTENT_NAME_KEY):40}'
+            f"{p.get('confidence'):03.2f} {p.get(INTENT_NAME_KEY):40}"
         )
         choice = {
             INTENT_NAME_KEY: name_with_confidence,

rasa/core/training/interactive.py~L674

     await _print_history(conversation_id, endpoint)
 
     choices = [
-        {"name": f'{a["score"]:03.2f} {a["action"]:40}', "value": a["action"]}
+        {"name": f"{a['score']:03.2f} {a['action']:40}", "value": a["action"]}
         for a in predictions
     ]
 

Snowflake-Labs/snowcli (+1 -1 lines across 1 file)

ruff format --preview

tests/test_connection.py~L1268

             ["connection", "generate-jwt", "-c", "jwt"],
         )
         assert (
-            f'{attribute.capitalize().replace("_", " ")} is not set in the connection context'
+            f"{attribute.capitalize().replace('_', ' ')} is not set in the connection context"
             in result.output
         )

apache/airflow (+8 -8 lines across 5 files)

ruff format --preview

dev/breeze/src/airflow_breeze/commands/release_management_commands.py~L2035

     """Check if package has been prepared in dist folder."""
     return any(
         file.startswith((
-            f'apache_airflow_providers_{package.replace(".", "_")}',
-            f'apache-airflow-providers-{package.replace(".", "-")}',
+            f"apache_airflow_providers_{package.replace('.', '_')}",
+            f"apache-airflow-providers-{package.replace('.', '-')}",
         ))
         for file in dist_files
     )

dev/breeze/src/airflow_breeze/commands/release_management_commands.py~L2048

 def get_suffix_from_package_in_dist(dist_files: list[str], package: str) -> str | None:
     """Get suffix from package prepared in dist folder."""
     for file in dist_files:
-        if file.startswith(f'apache_airflow_providers_{package.replace(".", "_")}') and file.endswith(
+        if file.startswith(f"apache_airflow_providers_{package.replace('.', '_')}") and file.endswith(
             ".tar.gz"
         ):
             file = file[: -len(".tar.gz")]

dev/breeze/src/airflow_breeze/utils/packages.py~L714

             f"[error]Error {e}[/]\n"
             f"[error]When fetching tags from remote. Your tags might not be refreshed.[/]\n\n"
             f'[warning]Please refresh the tags manually via:[/]\n\n"'
-            f'{" ".join(fetch_command)}\n\n'
+            f"{' '.join(fetch_command)}\n\n"
         )
         sys.exit(1)
 

providers/src/airflow/providers/docker/decorators/docker.py~L161

             f"""bash -cx  '{
                 _generate_decode_command("__PYTHON_SCRIPT", "/tmp/script.py", self.python_command)
             } &&"""
-            f'{_generate_decode_command("__PYTHON_INPUT", "/tmp/script.in", self.python_command)} &&'
+            f"{_generate_decode_command('__PYTHON_INPUT', '/tmp/script.in', self.python_command)} &&"
             f"{self.python_command} /tmp/script.py /tmp/script.in /tmp/script.out none /tmp/script.out'"
         )
 

providers/tests/system/amazon/aws/example_sagemaker_endpoint.py~L211

     upload_data = S3CreateObjectOperator(
         task_id="upload_data",
         s3_bucket=test_setup["bucket_name"],
-        s3_key=f'{test_setup["input_data_s3_key"]}/train.csv',
+        s3_key=f"{test_setup['input_data_s3_key']}/train.csv",
         data=TRAIN_DATA,
     )
 

tests/models/test_dagbag.py~L498

         dag_id = expected_dag.dag_id
         actual_dagbag.log.info("validating %s", dag_id)
         assert (dag_id in actual_found_dag_ids) == should_be_found, (
-            f"dag \"{dag_id}\" should {'' if should_be_found else 'not '}"
+            f'dag "{dag_id}" should {"" if should_be_found else "not "}'
             f'have been found after processing dag "{expected_dag.dag_id}"'
         )
         assert (dag_id in actual_dagbag.dags) == should_be_found, (
-            f"dag \"{dag_id}\" should {'' if should_be_found else 'not '}"
+            f'dag "{dag_id}" should {"" if should_be_found else "not "}'
             f'be in dagbag.dags after processing dag "{expected_dag.dag_id}"'
         )
 

apache/superset (+7 -7 lines across 5 files)

ruff format --preview

superset/db_engine_specs/snowflake.py~L334

         if missing := sorted(required - present):
             errors.append(
                 SupersetError(
-                    message=f'One or more parameters are missing: {", ".join(missing)}',
+                    message=f"One or more parameters are missing: {', '.join(missing)}",
                     error_type=SupersetErrorType.CONNECTION_MISSING_PARAMETERS_ERROR,
                     level=ErrorLevel.WARNING,
                     extra={"missing": missing},

superset/sql_lab.py~L267

         if not query.tmp_table_name:
             start_dttm = datetime.fromtimestamp(query.start_time)
             query.tmp_table_name = (
-                f'tmp_{query.user_id}_table_{start_dttm.strftime("%Y_%m_%d_%H_%M_%S")}'
+                f"tmp_{query.user_id}_table_{start_dttm.strftime('%Y_%m_%d_%H_%M_%S')}"
             )
         sql = parsed_query.as_create_table(
             query.tmp_table_name,

superset/tags/api.py~L143

         """Deterministic string representation of the API instance for etag_cache."""
         return (
             "Superset.tags.api.TagRestApi@v"
-            f'{self.appbuilder.app.config["VERSION_STRING"]}'
-            f'{self.appbuilder.app.config["VERSION_SHA"]}'
+            f"{self.appbuilder.app.config['VERSION_STRING']}"
+            f"{self.appbuilder.app.config['VERSION_SHA']}"
         )
 
     @expose("/", methods=("POST",))

tests/integration_tests/datasets/api_tests.py~L723

 
         # cleanup
         data = json.loads(rv.data.decode("utf-8"))
-        uri = f'api/v1/dataset/{data.get("id")}'
+        uri = f"api/v1/dataset/{data.get('id')}"
         rv = self.client.delete(uri)
         assert rv.status_code == 200
         with example_db.get_sqla_engine() as engine:

tests/integration_tests/datasets/api_tests.py~L808

 
             # cleanup
             data = json.loads(rv.data.decode("utf-8"))
-            uri = f'api/v1/dataset/{data.get("id")}'
+            uri = f"api/v1/dataset/{data.get('id')}"
             rv = self.client.delete(uri)
             assert rv.status_code == 200
 

tests/integration_tests/datasource_tests.py~L541

 
     sql = (
         f"select * from ({virtual_dataset.sql}) as tbl "
-        f'limit {app.config["SAMPLES_ROW_LIMIT"]}'
+        f"limit {app.config['SAMPLES_ROW_LIMIT']}"
     )
     eager_samples = virtual_dataset.database.get_df(sql)
 

aws/aws-sam-cli (+2 -2 lines across 2 files)

ruff format --preview

tests/integration/testdata/remote_invoke/lambda-fns/main.py~L9

     print("value2 = " + event["key2"])
     print("value3 = " + event["key3"])
 
-    return {"message": f'{event["key1"]} {event["key3"]}'}
+    return {"message": f"{event['key1']} {event['key3']}"}
 
 
 def custom_env_var_echo_handler(event, context):

tests/unit/commands/pipeline/init/test_initeractive_init_flow.py~L188

             str(["2", "pipeline_execution_role"]): "arn:aws:iam::123456789012:role/execution-role",
             str(["default", "pipeline_execution_role"]): "arn:aws:iam::123456789012:role/execution-role",
             str(["stage_names_message"]): "Here are the stage configuration names detected "
-            f'in {os.path.join(".aws-sam", "pipeline", "pipelineconfig.toml")}:\n\t1 - testing\n\t2 - prod',
+            f"in {os.path.join('.aws-sam', 'pipeline', 'pipelineconfig.toml')}:\n\t1 - testing\n\t2 - prod",
             "shared_values": "default",
         })
         cookiecutter_mock.assert_called_once_with(

binary-husky/gpt_academic (+12 -12 lines across 8 files)

ruff format --preview

crazy_functions/Conversation_To_File.py~L246

         local_history = "<br/>".join([
             "`" + hide_cwd(f) + f" ({gen_file_preview(f)})" + "`"
             for f in glob.glob(
-                f'{get_log_folder(get_user(chatbot), plugin_name="chat_history")}/**/{f_prefix}*.html',
+                f"{get_log_folder(get_user(chatbot), plugin_name='chat_history')}/**/{f_prefix}*.html",
                 recursive=True,
             )
         ])

crazy_functions/Conversation_To_File.py~L285

     local_history = "<br/>".join([
         "`" + hide_cwd(f) + "`"
         for f in glob.glob(
-            f'{get_log_folder(get_user(chatbot), plugin_name="chat_history")}/**/{f_prefix}*.html',
+            f"{get_log_folder(get_user(chatbot), plugin_name='chat_history')}/**/{f_prefix}*.html",
             recursive=True,
         )
     ])
     for f in glob.glob(
-        f'{get_log_folder(get_user(chatbot), plugin_name="chat_history")}/**/{f_prefix}*.html',
+        f"{get_log_folder(get_user(chatbot), plugin_name='chat_history')}/**/{f_prefix}*.html",
         recursive=True,
     ):
         os.remove(f)

crazy_functions/Markdown_Translate.py~L193

                 txt = txt.replace("/blob/", "/")
 
         r = requests.get(txt, proxies=proxies)
-        download_local = f'{get_log_folder(plugin_name="批量Markdown翻译")}/raw-readme-{gen_time_str()}.md'
-        project_folder = f'{get_log_folder(plugin_name="批量Markdown翻译")}'
+        download_local = f"{get_log_folder(plugin_name='批量Markdown翻译')}/raw-readme-{gen_time_str()}.md"
+        project_folder = f"{get_log_folder(plugin_name='批量Markdown翻译')}"
         with open(download_local, "wb+") as f:
             f.write(r.content)
         file_manifest = [download_local]

crazy_functions/Social_Helper.py~L182

 
         try:
             Explaination = "\n".join([
-                f'{k}: {v["explain_to_llm"]}' for k, v in self.tools_to_select.items()
+                f"{k}: {v['explain_to_llm']}" for k, v in self.tools_to_select.items()
             ])
 
             class UserSociaIntention(BaseModel):

crazy_functions/gen_fns/gen_fns_shared.py~L22

 
 def try_make_module(code, chatbot):
     module_file = "gpt_fn_" + gen_time_str().replace("-", "_")
-    fn_path = f'{get_log_folder(plugin_name="gen_plugin_verify")}/{module_file}.py'
+    fn_path = f"{get_log_folder(plugin_name='gen_plugin_verify')}/{module_file}.py"
     with open(fn_path, "w", encoding="utf8") as f:
         f.write(code)
     promote_file_to_downloadzone(fn_path, chatbot=chatbot)

crazy_functions/gen_fns/gen_fns_shared.py~L70

     return_dict["traceback"] = ""
     try:
         module_file = "gpt_fn_" + gen_time_str().replace("-", "_")
-        fn_path = f'{get_log_folder(plugin_name="gen_plugin_run")}/{module_file}.py'
+        fn_path = f"{get_log_folder(plugin_name='gen_plugin_run')}/{module_file}.py"
         with open(fn_path, "w", encoding="utf8") as f:
             f.write(code)
         class_name = get_class_name(code)

crazy_functions/vt_fns/vt_call_plugin.py~L187

     # ⭐ ⭐ ⭐ 执行插件
     fn = plugin["Function"]
     fn_name = fn.__name__
-    msg = f'{llm_kwargs["llm_model"]}为您选择了插件: `{fn_name}`\n\n插件说明：{plugin["Info"]}\n\n插件参数：{plugin_sel.plugin_arg}\n\n假如偏离了您的要求，按停止键终止。'
+    msg = f"{llm_kwargs['llm_model']}为您选择了插件: `{fn_name}`\n\n插件说明：{plugin['Info']}\n\n插件参数：{plugin_sel.plugin_arg}\n\n假如偏离了您的要求，按停止键终止。"
     yield from update_ui_lastest_msg(
         lastmsg=msg, chatbot=chatbot, history=history, delay=2
     )

request_llms/bridge_all.py~L1170

             raise ValueError("AZURE_CFG_ARRAY中配置的模型必须以azure开头")
         endpoint_ = (
             azure_cfg_dict["AZURE_ENDPOINT"]
-            + f'openai/deployments/{azure_cfg_dict["AZURE_ENGINE"]}/chat/completions?api-version=2023-05-15'
+            + f"openai/deployments/{azure_cfg_dict['AZURE_ENGINE']}/chat/completions?api-version=2023-05-15"
         )
         model_info.update({
             azure_model_name: {

request_llms/com_google.py~L101

 def html_local_file(file):
     base_path = os.path.dirname(__file__)  # 项目目录
     if os.path.exists(str(file)):
-        file = f'file={file.replace(base_path, ".")}'
+        file = f"file={file.replace(base_path, '.')}"
     return file
 
 

shared_utils/handle_upload.py~L14

 def html_local_file(file):
     base_path = os.path.dirname(__file__)  # 项目目录
     if os.path.exists(str(file)):
-        file = f'file={file.replace(base_path, ".")}'
+        file = f"file={file.replace(base_path, '.')}"
     return file
 
 

bokeh/bokeh (+1 -1 lines across 1 file)

ruff format --preview

scripts/milestone.py~L67

     """Returns a humanized description of the given issue or PR data."""
     component = get_label_component(data)
     component_str = "" if not component else f"[component: {component}] "
-    return f'#{data["node"]["number"]} {component_str}{data["node"]["title"]}'
+    return f"#{data['node']['number']} {component_str}{data['node']['title']}"
 
 
 def get_milestone_number(title, token, allow_closed):

fronzbot/blinkpy (+3 -3 lines across 2 files)

ruff format --preview

blinksync/blinksync.py~L65

             await my_sync.refresh()
             if my_sync.local_storage and my_sync.local_storage_manifest_ready:
                 print("Manifest is ready")
-                print(f"Manifest {my_sync._local_storage["manifest"]}")
+                print(f"Manifest {my_sync._local_storage['manifest']}")
             else:
                 print("Manifest not ready")
             for name, camera in blink.cameras.items():

blinksync/blinksync.py~L91

                         await item.prepare_download(blink)
                         await item.download_video(
                             blink,
-                            f"{path}/{item.name}_{item.created_at.astimezone().isoformat().replace(":", "_")}.mp4",
+                            f"{path}/{item.name}_{item.created_at.astimezone().isoformat().replace(':', '_')}.mp4",
                         )
                     if button == DELETE:
                         await item.delete_video(blink)

tests/test_camera_functions.py~L119

                     f"temperature response {mock_resp.return_value}."
                 ),
                 (
-                    f"WARNING:blinkpy.camera:for network_id ({config["network_id"]}) "
+                    f"WARNING:blinkpy.camera:for network_id ({config['network_id']}) "
                     f"and camera_id ({self.camera.camera_id})"
                 ),
                 ("WARNING:blinkpy.camera:Could not find thumbnail for camera new."),

ibis-project/ibis (+1 -1 lines across 1 file)

ruff format --preview

ibis/backends/clickhouse/tests/test_client.py~L362

 
 
 def test_password_with_bracket():
-    password = f'{os.environ.get("IBIS_TEST_CLICKHOUSE_PASSWORD", "")}[]'
+    password = f"{os.environ.get('IBIS_TEST_CLICKHOUSE_PASSWORD', '')}[]"
     quoted_pass = quote_plus(password)
     host = os.environ.get("IBIS_TEST_CLICKHOUSE_HOST", "localhost")
     user = os.environ.get("IBIS_TEST_CLICKHOUSE_USER", "default")

langchain-ai/langchain (+16 -16 lines across 6 files)

ruff format --preview

docs/docs/how_to/chat_token_usage_tracking.ipynb~L138

     }
    ],
    "source": [
-    "print(f'OpenAI: {openai_response.response_metadata[\"token_usage\"]}\\n')\n",
-    "print(f'Anthropic: {anthropic_response.response_metadata[\"usage\"]}')"
+    "print(f\"OpenAI: {openai_response.response_metadata['token_usage']}\\n\")\n",
+    "print(f\"Anthropic: {anthropic_response.response_metadata['usage']}\")"
    ]
   },
   {

docs/docs/how_to/chat_token_usage_tracking.ipynb~L307

     "\n",
     "async for event in structured_llm.astream_events(\"Tell me a joke\", version=\"v2\"):\n",
     "    if event[\"event\"] == \"on_chat_model_end\":\n",
-    "        print(f'Token usage: {event[\"data\"][\"output\"].usage_metadata}\\n')\n",
+    "        print(f\"Token usage: {event['data']['output'].usage_metadata}\\n\")\n",
     "    elif event[\"event\"] == \"on_chain_end\":\n",
     "        print(event[\"data\"][\"output\"])\n",
     "    else:\n",

docs/docs/how_to/message_history.ipynb~L376

    "source": [
     "state = app.get_state(config).values\n",
     "\n",
-    "print(f'Language: {state[\"language\"]}')\n",
+    "print(f\"Language: {state['language']}\")\n",
     "for message in state[\"messages\"]:\n",
     "    message.pretty_print()"
    ]

docs/docs/how_to/message_history.ipynb~L427

    "source": [
     "state = app.get_state(config).values\n",
     "\n",
-    "print(f'Language: {state[\"language\"]}')\n",
+    "print(f\"Language: {state['language']}\")\n",
     "for message in state[\"messages\"]:\n",
     "    message.pretty_print()"
    ]

libs/cli/langchain_cli/namespaces/app.py~L249

 
     chain_names = []
     for e in installed_exports:
-        original_candidate = f'{e["package_name"].replace("-", "_")}_chain'
+        original_candidate = f"{e['package_name'].replace('-', '_')}_chain"
         candidate = original_candidate
         i = 2
         while candidate in chain_names:

libs/community/langchain_community/graphs/neo4j_graph.py~L178

                         example = (
                             (
                                 "Available options: "
-                                f'{[clean_string_values(el) for el in prop["values"]]}'
+                                f"{[clean_string_values(el) for el in prop['values']]}"
                             )
                             if prop["values"]
                             else ""

libs/community/langchain_community/graphs/neo4j_graph.py~L192

                     "LOCAL_DATE_TIME",
                 ]:
                     if prop.get("min") is not None:
-                        example = f'Min: {prop["min"]}, Max: {prop["max"]}'
+                        example = f"Min: {prop['min']}, Max: {prop['max']}"
                     else:
                         example = (
                             f'Example: "{prop["values"][0]}"'

libs/community/langchain_community/graphs/neo4j_graph.py~L204

                     if not prop.get("min_size") or prop["min_size"] > LIST_LIMIT:
                         continue
                     example = (
-                        f'Min Size: {prop["min_size"]}, Max Size: {prop["max_size"]}'
+                        f"Min Size: {prop['min_size']}, Max Size: {prop['max_size']}"
                     )
                 formatted_node_props.append(
                     f"  - `{prop['property']}`: {prop['type']} {example}"

libs/community/langchain_community/graphs/neo4j_graph.py~L226

                         example = (
                             (
                                 "Available options: "
-                                f'{[clean_string_values(el) for el in prop["values"]]}'
+                                f"{[clean_string_values(el) for el in prop['values']]}"
                             )
                             if prop["values"]
                             else ""

libs/community/langchain_community/graphs/neo4j_graph.py~L239

                     "LOCAL_DATE_TIME",
                 ]:
                     if prop.get("min"):  # If we have min/max
-                        example = f'Min: {prop["min"]}, Max:  {prop["max"]}'
+                        example = f"Min: {prop['min']}, Max:  {prop['max']}"
                     else:  # return a single value
                         example = (
                             f'Example: "{prop["values"][0]}"' if prop["values"] else ""

libs/community/langchain_community/graphs/neo4j_graph.py~L249

                     if not prop.get("min_size") or prop["min_size"] > LIST_LIMIT:
                         continue
                     example = (
-                        f'Min Size: {prop["min_size"]}, Max Size: {prop["max_size"]}'
+                        f"Min Size: {prop['min_size']}, Max Size: {prop['max_size']}"
                     )
                 formatted_rel_props.append(
                     f"  - `{prop['property']}: {prop['type']}` {example}"

libs/community/langchain_community/vectorstores/typesense.py~L159

         embedded_query = [str(x) for x in self._embedding.embed_query(query)]
         query_obj = {
             "q": "*",
-            "vector_query": f'vec:([{",".join(embedded_query)}], k:{k})',
+            "vector_query": f"vec:([{','.join(embedded_query)}], k:{k})",
             "filter_by": filter,
             "collection": self._typesense_collection_name,
         }

templates/neo4j-semantic-ollama/neo4j_semantic_ollama/recommendation_tool.py~L78

         try:
             return (
                 "Recommended movies are: "
-                f'{f"###Movie {nl}".join([el["movie"] for el in response])}'
+                f"{f'###Movie {nl}'.join([el['movie'] for el in response])}"
             )
         except Exception:
             return "Can you tell us about some of the movies you liked?"

templates/neo4j-semantic-ollama/neo4j_semantic_ollama/recommendation_tool.py~L88

         try:
             return (
                 "Recommended movies are: "
-                f'{f"###Movie {nl}".join([el["movie"] for el in response])}'
+                f"{f'###Movie {nl}'.join([el['movie'] for el in response])}"
             )
         except Exception:
             return "Something went wrong"

templates/neo4j-semantic-ollama/neo4j_semantic_ollama/recommendation_tool.py~L102

     try:
         return (
             "Recommended movies are: "
-            f'{f"###Movie {nl}".join([el["movie"] for el in response])}'
+            f"{f'###Movie {nl}'.join([el['movie'] for el in response])}"
         )
     except Exception:
         return "Something went wrong"

latchbio/latch (+1 -1 lines across 1 file)

ruff format --preview

latch_cli/services/move.py~L156

                 raise e
 
     if len(srcs) == 1:
-        src_str = f'{click.style("Source: ", fg="blue")}{srcs[0]}'
+        src_str = f"{click.style('Source: ', fg='blue')}{srcs[0]}"
     else:
         src_str = "\n".join([
             click.style("Sources: ", fg="blue"),

lnbits/lnbits (+7 -7 lines across 2 files)

ruff format --preview

lnbits/wallets/phoenixd.py~L232

                             and message_json.get("type") == "payment_received"
                         ):
                             logger.info(
-                                f'payment-received: {message_json["paymentHash"]}'
+                                f"payment-received: {message_json['paymentHash']}"
                             )
                             yield message_json["paymentHash"]
 

tests/regtest/test_real_invoice.py~L45

 
     # check the payment status
     response = await client.get(
-        f'/api/v1/payments/{invoice["payment_hash"]}', headers=inkey_headers_from
+        f"/api/v1/payments/{invoice['payment_hash']}", headers=inkey_headers_from
     )
     assert response.status_code < 300
     payment_status = response.json()

tests/regtest/test_real_invoice.py~L74

     invoice = response.json()
 
     response = await client.get(
-        f'/api/v1/payments/{invoice["payment_hash"]}', headers=inkey_headers_from
+        f"/api/v1/payments/{invoice['payment_hash']}", headers=inkey_headers_from
     )
     assert response.status_code < 300
     payment_status = response.json()

tests/regtest/test_real_invoice.py~L84

         assert payment.checking_id == invoice["payment_hash"]
 
         response = await client.get(
-            f'/api/v1/payments/{invoice["payment_hash"]}', headers=inkey_headers_from
+            f"/api/v1/payments/{invoice['payment_hash']}", headers=inkey_headers_from
         )
         assert response.status_code < 300
         payment_status = response.json()

tests/regtest/test_real_invoice.py~L128

 
     # check the payment status
     response = await client.get(
-        f'/api/v1/payments/{invoice["payment_hash"]}', headers=inkey_headers_from
+        f"/api/v1/payments/{invoice['payment_hash']}", headers=inkey_headers_from
     )
     payment_status = response.json()
     assert payment_status["paid"]

tests/regtest/test_real_invoice.py~L290

     assert response.status_code < 300
     invoice = response.json()
     response = await client.get(
-        f'/api/v1/payments/{invoice["payment_hash"]}', headers=inkey_headers_from
+        f"/api/v1/payments/{invoice['payment_hash']}", headers=inkey_headers_from
     )
     payment_status = response.json()
     assert not payment_status["paid"]

tests/regtest/test_real_invoice.py~L299

         assert payment.checking_id == invoice["payment_hash"]
 
         response = await client.get(
-            f'/api/v1/payments/{invoice["payment_hash"]}', headers=inkey_headers_from
+            f"/api/v1/payments/{invoice['payment_hash']}", headers=inkey_headers_from
         )
         assert response.status_code < 300
         payment_status = response.json()

milvus-io/pymilvus (+2 -2 lines across 2 files)

ruff format --preview

examples/hello_hybrid_bm25.py~L157

         print(f"text: {hit.text} distance {hit.score}")
 else:
     for hit in res:
-        print(f'text: {hit.fields["text"]} distance {hit.distance}')
+        print(f"text: {hit.fields['text']} distance {hit.distance}")
 
 # If you used both BGE-M3 and the reranker, you should see the following:
 # text: Alan Turing was the first person to conduct substantial research in AI. distance 0.9306981017573297

examples/hello_hybrid_sparse_dense.py~L151

         print(f"text: {hit.text} distance {hit.score}")
 else:
     for hit in res:
-        print(f'text: {hit.fields["text"]} distance {hit.distance}')
+        print(f"text: {hit.fields['text']} distance {hit.distance}")
 
 # If you used both BGE-M3 and the reranker, you should see the following:
 # text: Alan Turing was the first person to conduct substantial research in AI. distance 0.9306981017573297

mlflow/mlflow (+3 -3 lines across 2 files)

ruff format --preview

tests/recipes/test_ingest_step.py~L103

     pandas_df_part2 = pandas_df[1:]
     pandas_df_part1.to_csv(dataset_path / "df1.csv")
     pandas_df_part2.to_csv(dataset_path / "df2.csv")
-    dataset_path = [f'{dataset_path / "df1.csv"}', f'{dataset_path / "df2.csv"}']
+    dataset_path = [f"{dataset_path / 'df1.csv'}", f"{dataset_path / 'df2.csv'}"]
 
     recipe_yaml = tmp_recipe_root_path.joinpath(_RECIPE_CONFIG_FILE_NAME)
     recipe_yaml.write_text(

tests/recipes/test_ingest_step.py~L158

         dataset_path = pathlib.Path(os.path.relpath(dataset_path))
 
     if explicit_file_list and multiple_files:
-        dataset_path = [f'{dataset_path / "df1.csv"}', f'{dataset_path / "df2.csv"}']
+        dataset_path = [f"{dataset_path / 'df1.csv'}", f"{dataset_path / 'df2.csv'}"]
     else:
         dataset_path = str(dataset_path)
 

tests/server/auth/test_auth.py~L114

 
     # authenticate with the newly created user
     headers = {
-        "Authorization": f'Bearer {jwt.encode({"username": username}, "secret", algorithm="HS256")}'
+        "Authorization": f"Bearer {jwt.encode({'username': username}, 'secret', algorithm='HS256')}"
     }
     _mlflow_search_experiments_rest(client.tracking_uri, headers)
 

pandas-dev/pandas (+6 -6 lines across 3 files)

ruff format --preview

pandas/io/formats/xml.py~L404

                         f"{self.prefix} is not included in namespaces"
                     ) from err
             elif "" in self.namespaces:
-                uri = f'{{{self.namespaces[""]}}}'
+                uri = f"{{{self.namespaces['']}}}"
             else:
                 uri = ""
 

pandas/io/formats/xml.py~L502

                         f"{self.prefix} is not included in namespaces"
                     ) from err
             elif "" in self.namespaces:
-                uri = f'{{{self.namespaces[""]}}}'
+                uri = f"{{{self.namespaces['']}}}"
             else:
                 uri = ""
 

pandas/tests/io/json/test_pandas.py~L1776

     )
     def test_read_json_with_very_long_file_path(self, compression):
         # GH 46718
-        long_json_path = f'{"a" * 1000}.json{compression}'
+        long_json_path = f"{'a' * 1000}.json{compression}"
         with pytest.raises(
             FileNotFoundError, match=f"File {long_json_path} does not exist"
         ):

scripts/validate_docstrings.py~L368

         )
         for err_code in actual_failures - expected_failures:
             sys.stdout.write(
-                f'{prefix}{res["file"]}:{res["file_line"]}:'
+                f"{prefix}{res['file']}:{res['file_line']}:"
                 f"{err_code}:{func_name}:{error_messages[err_code]}\n"
             )
             exit_status += 1
         for err_code in ignore_errors.get(func_name, set()) - actual_failures:
             sys.stdout.write(
-                f'{prefix}{res["file"]}:{res["file_line"]}:'
+                f"{prefix}{res['file']}:{res['file_line']}:"
                 f"{err_code}:{func_name}:"
                 "EXPECTED TO FAIL, BUT NOT FAILING\n"
             )

scripts/validate_docstrings.py~L407

 
     sys.stderr.write(header("Validation"))
     if result["errors"]:
-        sys.stderr.write(f'{len(result["errors"])} Errors found for `{func_name}`:\n')
+        sys.stderr.write(f"{len(result['errors'])} Errors found for `{func_name}`:\n")
         for err_code, err_desc in result["errors"]:
             sys.stderr.write(f"\t{err_code}\t{err_desc}\n")
     else:

prefecthq/prefect (+1 -1 lines across 1 file)

ruff format --preview

src/prefect/blocks/core.py~L623

         qualified_name = to_qualified_name(cls)
         module_str = ".".join(qualified_name.split(".")[:-1])
         class_name = cls.__name__
-        block_variable_name = f'{cls.get_block_type_slug().replace("-", "_")}_block'
+        block_variable_name = f"{cls.get_block_type_slug().replace('-', '_')}_block"
 
         return dedent(
             f"""\

pypa/build (+1 -1 lines across 1 file)

ruff format --preview

src/build/main.py~L323

         '--version',
         '-V',
         action='version',
-        version=f"build {build.__version__} ({','.join(build.__path__)})",
+        version=f'build {build.__version__} ({",".join(build.__path__)})',
     )
     parser.add_argument(
         '--verbose',

pypa/cibuildwheel (+3 -3 lines across 1 file)

ruff format --preview

test/utils.py~L293

 
             if machine_arch == "arm64":
                 arm64_macosx = _floor_macosx(min_macosx, "11.0")
-                platform_tags = [f'macosx_{arm64_macosx.replace(".", "_")}_arm64']
+                platform_tags = [f"macosx_{arm64_macosx.replace('.', '_')}_arm64"]
             else:
-                platform_tags = [f'macosx_{min_macosx.replace(".", "_")}_x86_64']
+                platform_tags = [f"macosx_{min_macosx.replace('.', '_')}_x86_64"]
 
             if include_universal2:
-                platform_tags.append(f'macosx_{min_macosx.replace(".", "_")}_universal2')
+                platform_tags.append(f"macosx_{min_macosx.replace('.', '_')}_universal2")
         else:
             msg = f"Unsupported platform {platform!r}"
             raise Exception(msg)

python/mypy (+2 -2 lines across 2 files)

ruff format --preview

mypy/errors.py~L898

                     a.append(" " * DEFAULT_SOURCE_OFFSET + source_line_expanded)
                     marker = "^"
                     if end_line == line and end_column > column:
-                        marker = f'^{"~" * (end_column - column - 1)}'
+                        marker = f"^{'~' * (end_column - column - 1)}"
                     a.append(" " * (DEFAULT_SOURCE_OFFSET + column) + marker)
         return a
 

mypy/stubtest.py~L1554

 
 
 def describe_runtime_callable(signature: inspect.Signature, *, is_async: bool) -> str:
-    return f'{"async " if is_async else ""}def {signature}'
+    return f"{'async ' if is_async else ''}def {signature}"
 
 
 def is_subtype_helper(left: mypy.types.Type, right: mypy.types.Type) -> bool:

python/typeshed (+1 -1 lines across 1 file)

ruff format --preview

scripts/stubsabot.py~L533

     output = subprocess.check_output(["git", "remote", "get-url", "origin"], text=True).strip()
     match = re.match(r"(git@github.com:|https://github.com/)(?P<owner>[^/]+)/(?P<repo>[^/\s]+)", output)
     assert match is not None, f"Couldn't identify origin's owner: {output!r}"
-    assert match.group("repo").removesuffix(".git") == "typeshed", f'Unexpected repo: {match.group("repo")!r}'
+    assert match.group("repo").removesuffix(".git") == "typeshed", f"Unexpected repo: {match.group('repo')!r}"
     return match.group("owner")
 
 

reflex-dev/reflex (+3 -3 lines across 2 files)

ruff format --preview

reflex/custom_components/custom_components.py~L770

     pyproject_toml = _get_package_config()
     project = pyproject_toml["project"]
     console.print(
-        f'Double check the information before publishing: {project["name"]} version {project["version"]}'
+        f"Double check the information before publishing: {project['name']} version {project['version']}"
     )
 
     console.print("Update or enter to keep the current information.")

reflex/custom_components/custom_components.py~L782

     author["name"] = console.ask(f"Author Name", default=author.get("name", ""))
     author["email"] = console.ask(f"Author Email", default=author.get("email", ""))
 
-    console.print(f'Current keywords are: {project.get("keywords") or []}')
+    console.print(f"Current keywords are: {project.get('keywords') or []}")
     keyword_action = console.ask(
         "Keep, replace or append?", choices=["k", "r", "a"], default="k"
     )

reflex/vars/base.py~L364

 
                 _default_var_type: ClassVar[GenericType] = python_types[0]
 
-            ToVarOperation.__name__ = f'To{cls.__name__.removesuffix("Var")}Operation'
+            ToVarOperation.__name__ = f"To{cls.__name__.removesuffix('Var')}Operation"
 
             _var_subclasses.append(VarSubclassEntry(cls, ToVarOperation, python_types))
 

rotki/rotki (+187 -187 lines across 83 files)

ruff format --preview

rotkehlchen/api/rest.py~L447

             f"{task_str} dies with exception: {greenlet.exception}.\n"
             f"Exception Name: {greenlet.exc_info[0]}\n"
             f"Exception Info: {greenlet.exc_info[1]}\n"
-            f'Traceback:\n {"".join(traceback.format_tb(greenlet.exc_info[2]))}',
+            f"Traceback:\n {''.join(traceback.format_tb(greenlet.exc_info[2]))}",
         )
         # also write an error for the task result if it's not the main greenlet
         if task_id is not None:

rotkehlchen/api/rest.py~L1479

             return api_response(
                 result=wrap_in_fail_result(
                     f"Failed to add {asset.asset_type!s} {asset.name} "
-                    f'since it already exists. Existing ids: {",".join(identifiers)}'
+                    f"since it already exists. Existing ids: {','.join(identifiers)}"
                 ),
                 status_code=HTTPStatus.CONFLICT,
             )

rotkehlchen/api/rest.py~L1716

                     message=msg,
                     status_code=HTTPStatus.CONFLICT,
                 )
-            log.debug(f'extracted {len(data["events"])} events from {filepath}')
+            log.debug(f"extracted {len(data['events'])} events from {filepath}")
             self.rotkehlchen.accountant.process_history(
                 start_ts=Timestamp(data["pnl_settings"]["from_timestamp"]),
                 end_ts=Timestamp(data["pnl_settings"]["to_timestamp"]),

rotkehlchen/api/rest.py~L3269

         """Return the current price of the assets in the target asset currency."""
         log.debug(
             f"Querying the current {target_asset.identifier} price of these assets: "
-            f'{", ".join([asset.identifier for asset in assets])}',
+            f"{', '.join([asset.identifier for asset in assets])}",
         )
         # Type is list instead of tuple here because you can't serialize a tuple
         assets_price: dict[Asset, list[Price | (int | None | bool)]] = {}

rotkehlchen/api/rest.py~L3376

         """
         log.debug(
             f"Querying the historical {target_asset.identifier} price of these assets: "
-            f'{", ".join(f"{asset.identifier} at {ts}" for asset, ts in assets_timestamp)}',
+            f"{', '.join(f'{asset.identifier} at {ts}' for asset, ts in assets_timestamp)}",
             assets_timestamp=assets_timestamp,
         )
         assets_price: defaultdict[Asset, defaultdict] = defaultdict(

rotkehlchen/api/v1/fields.py~L533

         if self.limit_to is not None and chain_id not in self.limit_to:
             raise ValidationError(
                 f"Given chain_id {value} is not one of "
-                f'{",".join([str(x) for x in self.limit_to])} as needed by the endpoint',
+                f"{','.join([str(x) for x in self.limit_to])} as needed by the endpoint",
             )
 
         return chain_id

rotkehlchen/api/v1/fields.py~L573

         if self.limit_to is not None and chain not in self.limit_to:
             raise ValidationError(
                 f"Given chain {value} is not one of "
-                f'{",".join([str(x) for x in self.limit_to])} as needed by the endpoint',
+                f"{','.join([str(x) for x in self.limit_to])} as needed by the endpoint",
             )
 
         return chain

rotkehlchen/api/v1/fields.py~L808

         if self.limit_to is not None and location not in self.limit_to:
             raise ValidationError(
                 f"Given location {value} is not one of "
-                f'{",".join([str(x) for x in self.limit_to])} as needed by the endpoint',
+                f"{','.join([str(x) for x in self.limit_to])} as needed by the endpoint",
             )
 
         return location

rotkehlchen/api/v1/fields.py~L930

             ):  # noqa: E501
                 raise ValidationError(
                     f"Given file {value.filename} does not end in any of "
-                    f'{",".join(self.allowed_extensions)}',
+                    f"{','.join(self.allowed_extensions)}",
                 )
 
             return value

rotkehlchen/api/v1/fields.py~L950

         ):  # noqa: E501
             raise ValidationError(
                 f"Given file {path} does not end in any of "
-                f'{",".join(self.allowed_extensions)}',
+                f"{','.join(self.allowed_extensions)}",
             )
 
         return path

rotkehlchen/api/v1/schemas.py~L342

             SUPPORTED_CHAIN_IDS
         ):
             raise ValidationError(
-                message=f'rotki does not support evm transactions for {data["evm_chain"]}',
+                message=f"rotki does not support evm transactions for {data['evm_chain']}",
                 field_name="evm_chain",
             )
 

rotkehlchen/api/v1/schemas.py~L482

         ).issubset(valid_ordering_attr):
             error_msg = (
                 f"order_by_attributes for trades can not be "
-                f'{",".join(set(data["order_by_attributes"]) - valid_ordering_attr)}'
+                f"{','.join(set(data['order_by_attributes']) - valid_ordering_attr)}"
             )
             raise ValidationError(
                 message=error_msg,

rotkehlchen/api/v1/schemas.py~L711

         ).issubset(valid_ordering_attr):
             error_msg = (
                 f"order_by_attributes for history event data can not be "
-                f'{",".join(set(data["order_by_attributes"]) - valid_ordering_attr)}'
+                f"{','.join(set(data['order_by_attributes']) - valid_ordering_attr)}"
             )
             raise ValidationError(
                 message=error_msg,

rotkehlchen/api/v1/schemas.py~L1001

         ).issubset(valid_ordering_attr):
             error_msg = (
                 f"order_by_attributes for asset movements can not be "
-                f'{",".join(set(data["order_by_attributes"]) - valid_ordering_attr)}'
+                f"{','.join(set(data['order_by_attributes']) - valid_ordering_attr)}"
             )
             raise ValidationError(
                 message=error_msg,

rotkehlchen/api/v1/schemas.py~L1195

 
     if (invalid_oracles := given_set - SETTABLE_CURRENT_PRICE_ORACLES) != set():
         raise ValidationError(
-            f'Invalid current price oracles given: {", ".join([str(x) for x in invalid_oracles])}. ',  # noqa: E501
+            f"Invalid current price oracles given: {', '.join([str(x) for x in invalid_oracles])}. ",  # noqa: E501
         )
 
 

rotkehlchen/api/v1/schemas.py~L1209

         oracle_names = [str(oracle) for oracle in historical_price_oracles]
         supported_oracle_names = [str(oracle) for oracle in HistoricalPriceOracle]
         raise ValidationError(
-            f'Invalid historical price oracles in: {", ".join(oracle_names)}. '
-            f'Supported oracles are: {", ".join(supported_oracle_names)}. '
+            f"Invalid historical price oracles in: {', '.join(oracle_names)}. "
+            f"Supported oracles are: {', '.join(supported_oracle_names)}. "
             f"Check there are no repeated ones.",
         )
 

rotkehlchen/api/v1/schemas.py~L1508

         if data.get("api_key") is None:
             if data["name"] != ExternalService.MONERIUM:
                 raise ValidationError(
-                    message=f'an api key is needed for {data["name"].name.lower()}',
+                    message=f"an api key is needed for {data['name'].name.lower()}",
                     field_name="api_key",
                 )
 

rotkehlchen/api/v1/schemas.py~L1702

         ).issubset(valid_ordering_attr):
             error_msg = (
                 f"order_by_attributes for accounting report data can not be "
-                f'{",".join(set(data["order_by_attributes"]) - valid_ordering_attr)}'
+                f"{','.join(set(data['order_by_attributes']) - valid_ordering_attr)}"
             )
             raise ValidationError(
                 message=error_msg,

rotkehlchen/api/v1/schemas.py~L2775

         ).issubset(valid_ordering_attr):
             error_msg = (
                 f"order_by_attributes for eth2 daily stats can not be "
-                f'{",".join(set(data["order_by_attributes"]) - valid_ordering_attr)}'
+                f"{','.join(set(data['order_by_attributes']) - valid_ordering_attr)}"
             )
             raise ValidationError(
                 message=error_msg,

rotkehlchen/api/v1/schemas.py~L2888

                 address = to_checksum_address(data["address"])
             except ValueError as e:
                 raise ValidationError(
-                    f'Given value {data["address"]} is not a valid {data["blockchain"]} address',
+                    f"Given value {data['address']} is not a valid {data['blockchain']} address",
                     field_name="address",
                 ) from e
         else:

rotkehlchen/api/v1/schemas.py~L2929

             )
         ):
             raise ValidationError(
-                f'Given value {data["address"]} is not a {blockchain} address',
+                f"Given value {data['address']} is not a {blockchain} address",
                 field_name="address",
             )
 

rotkehlchen/api/v1/schemas.py~L3096

             == data["location_data_snapshot"][0].time
         ):  # noqa: E501
             raise ValidationError(
-                f'timestamp provided {data["timestamp"]} is not the same as the '
+                f"timestamp provided {data['timestamp']} is not the same as the "
                 f"one for the entries provided.",
             )
 

rotkehlchen/api/v1/schemas.py~L3357

             ).fetchone()[0]
             if tx_count > 0:
                 raise ValidationError(
-                    message=f'tx_hash {data["tx_hash"].hex()} for {data["evm_chain"]} already present in the database',  # noqa: E501
+                    message=f"tx_hash {data['tx_hash'].hex()} for {data['evm_chain']} already present in the database",  # noqa: E501
                     field_name="tx_hash",
                 )
 

rotkehlchen/api/v1/schemas.py~L3367

             ).fetchone()[0]
             if accounts_count == 0:
                 raise ValidationError(
-                    message=f'address {data["associated_address"]} provided is not tracked by rotki for {data["evm_chain"]}',  # noqa: E501
+                    message=f"address {data['associated_address']} provided is not tracked by rotki for {data['evm_chain']}",  # noqa: E501
                     field_name="associated_address",
                 )
 

rotkehlchen/chain/aggregator.py~L535

         if len(bad_accounts) != 0:
             word = "already" if append_or_remove == "append" else "don't"
             raise InputError(
-                f'Blockchain account/s {",".join(bad_accounts)} {word} exist',
+                f"Blockchain account/s {','.join(bad_accounts)} {word} exist",
             )
 
     @protect_with_lock(arguments_matter=True)

rotkehlchen/chain/aggregator.py~L781

         if len(unknown_accounts) != 0:
             raise InputError(
                 f"Tried to remove unknown {blockchain.value} "
-                f'accounts {",".join(unknown_accounts)}',
+                f"accounts {','.join(unknown_accounts)}",
             )
 
         self.modify_blockchain_accounts(

rotkehlchen/chain/ethereum/airdrops.py~L41

 log = RotkehlchenLogsAdapter(logger)
 
 AIRDROPS_REPO_BASE: Final = (
-    f'https://github.com/raw/rotki/data/{"main" if is_production() else "develop"}'  # noqa: E501
+    f"https://github.com/raw/rotki/data/{'main' if is_production() else 'develop'}"  # noqa: E501
 )
 AIRDROPS_INDEX: Final = f"{AIRDROPS_REPO_BASE}/airdrops/index_v3.json"
 ETAG_CACHE_KEY: Final = "ETag"

rotkehlchen/chain/ethereum/modules/compound/v3/compound.py~L75

                 rates_calls[balance_type].append((
                     token_address,
                     token_contract.encode(
-                        method_name=f'get{"Supply" if balance_type == BalanceType.ASSET else "Borrow"}Rate',  # noqa: E501
+                        method_name=f"get{'Supply' if balance_type == BalanceType.ASSET else 'Borrow'}Rate",  ...*[Comment body truncated]*

[MichaReiser]

This not only fixes the issue where Ruff failed to change the quotes in Py312+ but now also ensures that f-strings use the preferred quote styles if nested literals uses the other quotes

[dhruvmanila]

This might make rustfmt mad so might want to do this locally

Suggested change

	if fstring
	.elements
	.iter()
	.filter_map(FStringElement::as_expression)
	.any(|expression| {
	if fstring
	.elements
	.expressions()
	.any(|expression| {

[MichaReiser]

Oh it's on elements. I always try to call it on the fstring

[dhruvmanila]

It's interesting that as a side effect we'll start fixing certain code that would raise a syntax error pre-3.12.

[dhruvmanila]

Is this correct? The outer single quotes got formatted to use double quotes even though the expression has a double quoted string, thus not using alternate quote style.

[MichaReiser]

Yes. The idea is that we use the same quote selection criteria as everywhere else and we keep using double quotes to avoid unnecessary escaping the single quote

[dhruvmanila]

This is great! I really like the ecosystem changes as well. I played around with random f-string with quotes but couldn't really find anything unexpected.

[MichaReiser]

I'll do another review of my own changes tomorrow and then plan to land this.