Automated Code Simplification: A Python Refactoring Tool

This challenge focuses on building a basic refactoring tool in Python that automatically simplifies code by identifying and replacing common code patterns with more concise equivalents. Refactoring is a crucial part of software development, and automating some of these tasks can significantly improve code readability and maintainability. You will implement a tool that identifies and replaces specific patterns, demonstrating a fundamental understanding of code analysis and transformation.

Problem Description

You are tasked with creating a Python refactoring tool that can automatically simplify code by replacing specific, well-defined patterns with more efficient or readable alternatives. The tool will take a Python code string as input and return a modified string with the identified patterns replaced. The initial focus will be on two patterns:

Replacing if x == True: with if x: This simplifies boolean checks.
Replacing if x == False: with if not x: This also simplifies boolean checks.

The tool should be able to handle multiple occurrences of these patterns within the input code. It should also be robust enough to avoid unintended replacements within strings or comments.

Key Requirements:

Pattern Identification: Accurately identify the target patterns within the input code.
Safe Replacement: Ensure that replacements are performed only in the intended contexts (e.g., not within string literals or comments).
Multiple Occurrences: Handle multiple instances of the patterns within the same code string.
Preservation of Code Structure: Maintain the overall structure and syntax of the code after the replacements.
Return Modified Code: Return the modified Python code string.

Expected Behavior:

The tool should take a string containing Python code as input and return a new string with the specified refactorings applied. The returned string should be valid Python code.

Edge Cases to Consider:

String Literals: The patterns should not be replaced within string literals (e.g., "if x == True:").
Comments: The patterns should not be replaced within comments (e.g., # if x == True:).
Nested Conditions: Handle cases where the patterns appear within nested if statements.
Whitespace: The refactoring should preserve whitespace as much as possible to maintain readability.
Empty Input: Handle the case where the input string is empty.

Examples

Example 1:

Input: "if x == True:\n    print('Hello')"
Output: "if x:\n    print('Hello')"
Explanation: The `if x == True:` pattern is replaced with `if x:`.

Example 2:

Input: "if y == False:\n    print('World')\nif z == True:"
Output: "if not y:\n    print('World')\nif z:"
Explanation: Both `if y == False:` and `if z == True:` are replaced with their simplified equivalents.

Example 3:

Input: "print('if x == True:')"
Output: "print('if x == True:')"
Explanation: The pattern is within a string literal and should not be replaced.

Example 4:

Input: "# if x == True:\nprint('Hello')"
Output: "# if x == True:\nprint('Hello')"
Explanation: The pattern is within a comment and should not be replaced.

Constraints

Input String Length: The input code string can be up to 1000 characters long.
Input Format: The input will be a string containing valid Python code (though it may not be perfectly formatted).
Performance: The refactoring process should complete within 0.5 seconds for the given input length. While optimization isn't the primary focus, avoid excessively inefficient algorithms.
No External Libraries: You are not allowed to use external libraries like ast for parsing and modifying the code. This is to focus on string manipulation techniques.

Notes

Regular expressions can be a useful tool for pattern matching, but be mindful of their potential complexity and performance implications.
Consider using string methods like replace() and find() to implement the refactoring logic.
Think carefully about how to avoid unintended replacements within strings and comments. Simple string replacement can be tricky; consider using delimiters or more sophisticated pattern matching.
Focus on correctness and clarity first, then consider optimization if necessary. The goal is to demonstrate an understanding of code refactoring principles, not to create a production-ready tool.