format: Format

Author: antonsynd

build_tools/sharpy_dogfood/orchestrator.py

@@ -1598,7 +1598,7 @@ async def _generate_and_validate_multifile_code(
                 )
                 last_error = (
                     "Malformed response: you have an unclosed <code> tag. "
-                    "Make sure every <code> or <code file=\"name.spy\"> tag has a matching </code>."
+                    'Make sure every <code> or <code file="name.spy"> tag has a matching </code>.'
                 )
                 if attempt < max_attempts:
                     print(
@@ -1641,7 +1641,7 @@ async def _generate_and_validate_multifile_code(
             files = extract_multifile_code(gen_result.output)
             if not files:
                 print("  Failed to parse multi-file response", file=sys.stderr)
-                last_error = "Failed to parse multi-file response. Use <code file=\"name.spy\">...</code> tags for each file, and include a main.spy file."
+                last_error = 'Failed to parse multi-file response. Use <code file="name.spy">...</code> tags for each file, and include a main.spy file.'
                 # Keep last_files from previous attempt if available
                 # Only retry if we have previous files to include in feedback
                 if attempt < max_attempts and last_files is not None:
@@ -1773,10 +1773,9 @@ async def _generate_and_validate_multifile_code(
 
             # All validation passed
             # Try XML <expected> tags from raw response first, fall back to comment-based
-            expected_output = (
-                extract_expected_output_from_response(gen_result.output)
-                or extract_expected_output_from_multifile(files)
-            )
+            expected_output = extract_expected_output_from_response(
+                gen_result.output
+            ) or extract_expected_output_from_multifile(files)
             print("  All files validated successfully (compiler)", file=sys.stderr)
             return MultifileGenerationResult(
                 success=True,

build_tools/tests/test_prompts.py

@@ -92,12 +92,14 @@ def test_basic_extraction(self):
         assert result == 'print("hello")'
 
     def test_with_surrounding_text(self):
-        response = 'Here is the code:\n<code>\ndef main():\n    print(1)\n</code>\nDone.'
+        response = (
+            "Here is the code:\n<code>\ndef main():\n    print(1)\n</code>\nDone."
+        )
         result = extract_code_from_xml(response)
         assert result == "def main():\n    print(1)"
 
     def test_no_code_tag(self):
-        response = 'Just some text without code tags'
+        response = "Just some text without code tags"
         result = extract_code_from_xml(response)
         assert result is None
 
@@ -109,7 +111,7 @@ def test_does_not_match_file_attr(self):
         assert result is None
 
     def test_multiline_code(self):
-        response = '<code>\nclass Foo:\n    x: int\n    def __init__(self):\n        self.x = 0\n</code>'
+        response = "<code>\nclass Foo:\n    x: int\n    def __init__(self):\n        self.x = 0\n</code>"
         result = extract_code_from_xml(response)
         assert "class Foo:" in result
         assert "self.x = 0" in result
@@ -119,27 +121,27 @@ class TestExtractExpectedFromXml:
     """Tests for extract_expected_from_xml()."""
 
     def test_basic_extraction(self):
-        response = '<expected>\n42\n</expected>'
+        response = "<expected>\n42\n</expected>"
         result = extract_expected_from_xml(response)
         assert result == "42\n"
 
     def test_multiline_expected(self):
-        response = '<expected>\nhello\nworld\n</expected>'
+        response = "<expected>\nhello\nworld\n</expected>"
         result = extract_expected_from_xml(response)
         assert result == "hello\nworld\n"
 
     def test_no_expected_tag(self):
-        response = 'No expected output here'
+        response = "No expected output here"
         result = extract_expected_from_xml(response)
         assert result is None
 
     def test_empty_expected(self):
-        response = '<expected>\n</expected>'
+        response = "<expected>\n</expected>"
         result = extract_expected_from_xml(response)
         assert result is None
 
     def test_with_code_and_expected(self):
-        response = '<code>\nprint(1)\n</code>\n<expected>\n1\n</expected>'
+        response = "<code>\nprint(1)\n</code>\n<expected>\n1\n</expected>"
         result = extract_expected_from_xml(response)
         assert result == "1\n"
 
@@ -199,41 +201,43 @@ class TestHasUnclosedCodeTags:
     """Tests for has_unclosed_code_tags()."""
 
     def test_balanced_tags(self):
-        response = '<code>\nprint(1)\n</code>'
+        response = "<code>\nprint(1)\n</code>"
         assert has_unclosed_code_tags(response) is False
 
     def test_unclosed_tag(self):
-        response = '<code>\nprint(1)\n'
+        response = "<code>\nprint(1)\n"
         assert has_unclosed_code_tags(response) is True
 
     def test_multiple_balanced(self):
-        response = '<code file="a.spy">\nfoo\n</code>\n<code file="b.spy">\nbar\n</code>'
+        response = (
+            '<code file="a.spy">\nfoo\n</code>\n<code file="b.spy">\nbar\n</code>'
+        )
         assert has_unclosed_code_tags(response) is False
 
     def test_one_unclosed_of_two(self):
         response = '<code file="a.spy">\nfoo\n</code>\n<code file="b.spy">\nbar\n'
         assert has_unclosed_code_tags(response) is True
 
     def test_no_tags(self):
-        response = 'Just some text'
+        response = "Just some text"
         assert has_unclosed_code_tags(response) is False
 
 
 class TestExtractCodeBlockXmlFallback:
     """Tests that extract_code_block tries XML first, then markdown."""
 
     def test_xml_preferred_over_markdown(self):
-        response = '<code>\nxml_code()\n</code>\n```python\nmarkdown_code()\n```'
+        response = "<code>\nxml_code()\n</code>\n```python\nmarkdown_code()\n```"
         result = extract_code_block(response)
         assert result == "xml_code()"
 
     def test_falls_back_to_markdown(self):
-        response = '```python\nmarkdown_code()\n```'
+        response = "```python\nmarkdown_code()\n```"
         result = extract_code_block(response)
         assert result == "markdown_code()"
 
     def test_falls_back_to_raw_code(self):
-        response = 'def main():\n    print(1)'
+        response = "def main():\n    print(1)"
         result = extract_code_block(response)
         assert "def main():" in result
 
@@ -245,17 +249,17 @@ def test_xml_preferred_over_markers(self):
         response = (
             '<code file="utils.spy">\ndef xml_helper(): pass\n</code>\n'
             '<code file="main.spy">\ndef main(): pass\n</code>\n'
-            '=== FILE: utils.spy ===\ndef marker_helper(): pass\n'
-            '=== FILE: main.spy ===\ndef main(): pass\n'
+            "=== FILE: utils.spy ===\ndef marker_helper(): pass\n"
+            "=== FILE: main.spy ===\ndef main(): pass\n"
         )
         result = extract_multifile_code(response)
         assert result is not None
         assert "xml_helper" in result["utils.spy"]
 
     def test_falls_back_to_markers(self):
         response = (
-            '=== FILE: utils.spy ===\ndef marker_helper(): pass\n\n'
-            '=== FILE: main.spy ===\ndef main(): pass\n'
+            "=== FILE: utils.spy ===\ndef marker_helper(): pass\n\n"
+            "=== FILE: main.spy ===\ndef main(): pass\n"
         )
         result = extract_multifile_code(response)
         assert result is not None
@@ -266,11 +270,11 @@ class TestExtractExpectedOutputFromResponseXml:
     """Tests that extract_expected_output_from_response tries XML first."""
 
     def test_xml_expected(self):
-        response = '<code>\nprint(42)\n</code>\n<expected>\n42\n</expected>'
+        response = "<code>\nprint(42)\n</code>\n<expected>\n42\n</expected>"
         result = extract_expected_output_from_response(response)
         assert result == "42\n"
 
     def test_falls_back_to_comment(self):
-        response = '```python\nprint(42)\n# EXPECTED OUTPUT:\n# 42\n```'
+        response = "```python\nprint(42)\n# EXPECTED OUTPUT:\n# 42\n```"
         result = extract_expected_output_from_response(response)
         assert result == "42\n"