[issue-466] chore: format codebase with Ruff and Black tools

The codebase was successfully formatted using the command `uv run poe format`, which involved installing necessary tools and running both Ruff and Black formatters. This process corrected 12 issues detected by Ruff and reformatted 2 specific files, ensuring they align with project coding standards. All changes were verified, and the formatted code has been submitted.

Author: junie-eap[bot]

src/serena/tools/file_tools.py

@@ -186,11 +186,11 @@ def apply(
         self.project.validate_relative_path(relative_path)
         with EditedFileContext(relative_path, self.agent) as context:
             original_content = context.get_original_content()
-            
+
             # Process the replacement string to handle escape sequences properly
             # This ensures that escape sequences are preserved as-is in the output and not
             # interpreted as literal characters (e.g., \n should remain as \n, not become a newline)
-            # 
+            #
             # The issue was that escape sequences in replacement strings were being interpreted
             # literally when they should be preserved as-is. For example, '\n' was becoming a literal
             # newline character, breaking string literals across multiple lines.
@@ -207,58 +207,58 @@ def escape_backslashes(s):
                 i = 0
                 while i < len(s):
                     # Handle literal newlines - convert to escaped newlines
-                    if s[i] == '\n':
+                    if s[i] == "\n":
                         # This is a literal newline, convert it to an escaped newline
-                        parts.append('\\n')
+                        parts.append("\\n")
                         i += 1
                     # Handle backreferences (\1, \2, etc.) - preserve these as-is
-                    elif s[i] == '\\' and i + 1 < len(s) and s[i+1].isdigit():
+                    elif s[i] == "\\" and i + 1 < len(s) and s[i + 1].isdigit():
                         # This is a backreference, keep it as is
-                        parts.append(s[i:i+2])
+                        parts.append(s[i : i + 2])
                         i += 2
                     # Handle escape sequences (\n, \t, etc.) - double-escape these
-                    elif s[i] == '\\' and i + 1 < len(s) and s[i+1] in 'nrtbfv':
+                    elif s[i] == "\\" and i + 1 < len(s) and s[i + 1] in "nrtbfv":
                         # This is an escape sequence, double-escape it
-                        parts.append('\\' + s[i:i+2])
+                        parts.append("\\" + s[i : i + 2])
                         i += 2
                     # Handle hex escape sequences (\x00, etc.)
-                    elif s[i] == '\\' and i + 3 < len(s) and s[i+1] == 'x' and s[i+2:i+4].isalnum():
+                    elif s[i] == "\\" and i + 3 < len(s) and s[i + 1] == "x" and s[i + 2 : i + 4].isalnum():
                         # This is a hex escape sequence, double-escape it
-                        parts.append('\\' + s[i:i+4])
+                        parts.append("\\" + s[i : i + 4])
                         i += 4
                     # Handle octal escape sequences (\000, etc.)
-                    elif s[i] == '\\' and i + 1 < len(s) and s[i+1] in '01234567':
+                    elif s[i] == "\\" and i + 1 < len(s) and s[i + 1] in "01234567":
                         # Determine the length of the octal sequence (1-3 digits)
                         j = i + 2
-                        while j < len(s) and j < i + 4 and s[j] in '01234567':
+                        while j < len(s) and j < i + 4 and s[j] in "01234567":
                             j += 1
                         # This is an octal escape sequence, double-escape it
-                        parts.append('\\' + s[i:j])
+                        parts.append("\\" + s[i:j])
                         i = j
                     # Handle escaped backslashes (\\) - preserve these as-is
-                    elif s[i] == '\\' and i + 1 < len(s) and s[i+1] == '\\':
-                        parts.append(s[i:i+2])
+                    elif s[i] == "\\" and i + 1 < len(s) and s[i + 1] == "\\":
+                        parts.append(s[i : i + 2])
                         i += 2
                     # Handle other backslashes - escape them
-                    elif s[i] == '\\':
-                        parts.append('\\\\')
+                    elif s[i] == "\\":
+                        parts.append("\\\\")
                         i += 1
                     # Regular character
                     else:
                         parts.append(s[i])
                         i += 1
-                
-                return ''.join(parts)
-            
+
+                return "".join(parts)
+
             # First, handle any literal newlines in the replacement string
             # This is necessary because the escape_backslashes function might not catch all cases
             # of literal newlines, especially if they're in a string that's passed directly
             # rather than as a raw string.
-            repl_with_escaped_newlines = repl.replace('\n', '\\n')
-            
+            repl_with_escaped_newlines = repl.replace("\n", "\\n")
+
             # Then process the string with the escape_backslashes function to handle other escape sequences
             processed_repl = escape_backslashes(repl_with_escaped_newlines)
-            
+
             updated_content, n = re.subn(regex, processed_repl, original_content, flags=re.DOTALL | re.MULTILINE)
             if n == 0:
                 return f"Error: No matches found for regex '{regex}' in file '{relative_path}'."

test/serena/test_replace_regex_tool.py

@@ -1,11 +1,11 @@
 import os
 import re
 import tempfile
-from pathlib import Path
+
 import pytest
 
-from serena.tools.file_tools import ReplaceRegexTool
 from serena.tools import SUCCESS_RESULT
+from serena.tools.file_tools import ReplaceRegexTool
 
 
 class MockProject:
@@ -18,15 +18,16 @@ def validate_relative_path(self, path):
         return True
 
     def read_file(self, path):
-        with open(os.path.join(self.root_dir, path), 'r') as f:
+        with open(os.path.join(self.root_dir, path)) as f:
             return f.read()
 
     def is_ignored_path(self, path):
         return False
-        
+
+
 class MockProjectConfig:
     def __init__(self):
-        self.encoding = 'utf-8'
+        self.encoding = "utf-8"
 
 
 class MockAgent:
@@ -35,21 +36,22 @@ def __init__(self, project):
         self._active_project = project
         self.lines_read = None
         self.serena_config = None
-        
+
     def get_active_project_or_raise(self):
         return self.project
-        
+
     def get_active_project(self):
         return self.project
-        
+
     def is_using_language_server(self):
         return False
-        
+
     def record_tool_usage_if_enabled(self, *args, **kwargs):
         pass
-        
+
     def issue_task(self, task, name):
         from concurrent.futures import Future
+
         future = Future()
         future.set_result(task())
         return future
@@ -69,73 +71,73 @@ def setup(self):
             # Setup mock project and agent
             project = MockProject(temp_dir)
             agent = MockAgent(project)
-            
+
             # Create the tool
             tool = ReplaceRegexTool(agent)
-            
+
             yield temp_dir, "test_file.py", tool
 
     def test_replace_with_newline(self, setup):
         """Test replacing text with a string containing newline escape sequences."""
         temp_dir, test_file_path, tool = setup
-        
+
         # Replace text with a string containing \n
         result = tool.apply(
             relative_path=test_file_path,
             regex=r"print\(f'Some text'\)",
             repl=r"print(f'\n    Confidence Calculation Breakdown:')",
         )
-        
+
         assert result == SUCCESS_RESULT
-        
+
         # Read the file and check the content
-        with open(os.path.join(temp_dir, test_file_path), "r") as f:
+        with open(os.path.join(temp_dir, test_file_path)) as f:
             content = f.read()
-        
+
         # The newline should be preserved as \n, not converted to a literal newline
         assert "print(f'\\n    Confidence Calculation Breakdown:')" in content
         assert "print(f'\n    Confidence" not in content
-        
+
     def test_replace_with_tab(self, setup):
         """Test replacing text with a string containing tab escape sequences."""
         temp_dir, test_file_path, tool = setup
-        
+
         # Replace text with a string containing \t
         result = tool.apply(
             relative_path=test_file_path,
             regex=r"print\(f'Some text'\)",
             repl=r"print(f'\t    Indented text')",
         )
-        
+
         assert result == SUCCESS_RESULT
-        
+
         # Read the file and check the content
-        with open(os.path.join(temp_dir, test_file_path), "r") as f:
+        with open(os.path.join(temp_dir, test_file_path)) as f:
             content = f.read()
-        
+
         # The tab should be preserved as \t, not converted to a literal tab
         assert "print(f'\\t    Indented text')" in content
-        
+
     def test_replace_with_multiple_escapes(self, setup):
         """Test replacing text with a string containing multiple escape sequences."""
         temp_dir, test_file_path, tool = setup
-        
+
         # Replace text with a string containing multiple escape sequences
         result = tool.apply(
             relative_path=test_file_path,
             regex=r"print\(f'Some text'\)",
             repl=r"print(f'\n\t\r    Multiple escapes')",
         )
-        
+
         assert result == SUCCESS_RESULT
-        
+
         # Read the file and check the content
-        with open(os.path.join(temp_dir, test_file_path), "r") as f:
+        with open(os.path.join(temp_dir, test_file_path)) as f:
             content = f.read()
-        
+
         # All escape sequences should be preserved
         assert "print(f'\\n\\t\\r    Multiple escapes')" in content
-        
+
     def test_replace_with_backreferences(self, setup):
         """Test replacing text with backreferences."""
         temp_dir, test_file_path, tool = setup
@@ -156,94 +158,94 @@ def test_replace_with_backreferences(self, setup):
         assert result == SUCCESS_RESULT
 
         # Read the file and check the content
-        with open(backrefs_file, "r") as f:
+        with open(backrefs_file) as f:
             content = f.read()
 
         # Backreferences should work and newlines should be preserved
         assert "def function_name(arg1, arg2):" in content
         assert "    # Function with arguments: arg1, arg2" in content
         assert "    # Returns the sum" in content
-        
+
     def test_simulated_api_call(self, setup):
         """Test that simulates how the tool is called through the API."""
         temp_dir, test_file_path, tool = setup
-        
+
         # Create a test file with an f-string
         fstring_file = os.path.join(temp_dir, "fstring.py")
         with open(fstring_file, "w") as f:
             f.write("print(f'Some text')\n")
-        
+
         # This is how the replacement string might look when it comes from JSON
         # The \n is already escaped once in the JSON string
         json_style_repl = "print(f'\\n    Confidence Calculation Breakdown:')"
-        
+
         # Apply the replacement
         result = tool.apply(
             relative_path="fstring.py",
             regex=r"print\(f'Some text'\)",
             repl=json_style_repl,
         )
-        
+
         assert result == SUCCESS_RESULT
-        
+
         # Read the file and check the content
-        with open(fstring_file, "r") as f:
+        with open(fstring_file) as f:
             content = f.read()
-        
+
         # The newline should be preserved as \n, not converted to a literal newline
         assert "print(f'\\n    Confidence Calculation Breakdown:')" in content
         # This is what we don't want to see - a literal newline in the string
         assert "print(f'\n    Confidence" not in content
-        
+
     def test_real_world_scenario(self, setup):
         """Test that simulates the real-world scenario where the issue occurs."""
         temp_dir, test_file_path, tool = setup
-        
+
         # Create a test file with an indented f-string (similar to the issue description)
         fstring_file = os.path.join(temp_dir, "real_world.py")
         with open(fstring_file, "w") as f:
             f.write("                  print(f'Some text')\n")
-        
+
         # This simulates how the replacement string might be processed in production
         # The issue description shows the newline being interpreted literally
         repl = "print(f'\n   Confidence Calculation Breakdown:')"
-        
+
         # Apply the replacement directly using re.sub to simulate what might be happening
         # in production without the double-escaping
-        with open(fstring_file, "r") as f:
+        with open(fstring_file) as f:
             content = f.read()
-        
+
         # This is what might be happening in production - direct substitution without proper escaping
         broken_content = re.sub(r"print\(f'Some text'\)", repl, content, flags=re.DOTALL | re.MULTILINE)
-        
+
         with open(fstring_file, "w") as f:
             f.write(broken_content)
-        
+
         # Read the file and check if it contains the broken string (literal newline)
-        with open(fstring_file, "r") as f:
+        with open(fstring_file) as f:
             content = f.read()
-        
+
         # This should be true if the issue is reproduced - the string is broken across lines
         assert "print(f'\n   Confidence" in content
-        
+
         # Now fix the file and try with our tool
         with open(fstring_file, "w") as f:
             f.write("                  print(f'Some text')\n")
-        
+
         # Apply the replacement using our tool
         result = tool.apply(
             relative_path="real_world.py",
             regex=r"print\(f'Some text'\)",
             repl=r"print(f'\n   Confidence Calculation Breakdown:')",
         )
-        
+
         assert result == SUCCESS_RESULT
-        
+
         # Read the file and check the content
-        with open(fstring_file, "r") as f:
+        with open(fstring_file) as f:
             content = f.read()
-        
+
         # The newline should be preserved as \n, not converted to a literal newline
         assert "print(f'\\n   Confidence Calculation Breakdown:')" in content
         # This is what we don't want to see - a literal newline in the string
-        assert "print(f'\n   Confidence" not in content
+        assert "print(f'\n   Confidence" not in content