Merge branch 'main' into multi-language

Author: KRRT7

codeflash/api/aiservice.py

@@ -298,7 +298,7 @@ def optimize_python_code_line_profiler(
         line_profiler_results: str,
         n_candidates: int,
         experiment_metadata: ExperimentMetadata | None = None,
-        is_numerical_code: bool | None = None,  # noqa: FBT001
+        is_numerical_code: bool | None = None,
         language: str = "python",
         language_version: str | None = None,
     ) -> list[OptimizedCandidate]:
@@ -814,7 +814,7 @@ def generate_regression_tests(
             error = response.json()["error"]
             logger.error(f"Error generating tests: {response.status_code} - {error}")
             ph("cli-testgen-error-response", {"response_status_code": response.status_code, "error": error})
-            return None  # noqa: TRY300
+            return None
         except Exception:
             logger.error(f"Error generating tests: {response.status_code} - {response.text}")
             ph("cli-testgen-error-response", {"response_status_code": response.status_code, "error": response.text})
@@ -830,7 +830,6 @@ def get_optimization_review(
         function_trace_id: str,
         coverage_message: str,
         replay_tests: str,
-        concolic_tests: str,  # noqa: ARG002
         calling_fn_details: str,
         language: str = "python",
     ) -> OptimizationReviewResult:

codeflash/api/cfapi.py

@@ -81,7 +81,7 @@ def make_cfapi_request(
         else:
             response = requests.get(url, headers=cfapi_headers, params=params, timeout=60)
         response.raise_for_status()
-        return response  # noqa: TRY300
+        return response
     except requests.exceptions.HTTPError:
         # response may be either a string or JSON, so we handle both cases
         error_message = ""
@@ -102,7 +102,7 @@ def make_cfapi_request(
 
 
 @lru_cache(maxsize=1)
-def get_user_id(api_key: Optional[str] = None) -> Optional[str]:  # noqa: PLR0911
+def get_user_id(api_key: Optional[str] = None) -> Optional[str]:
     """Retrieve the user's userid by making a request to the /cfapi/cli-get-user endpoint.
 
     :param api_key: The API key to use. If None, uses get_codeflash_api_key().
@@ -396,7 +396,7 @@ def get_blocklisted_functions() -> dict[str, set[str]] | dict[str, Any]:
 
 def is_function_being_optimized_again(
     owner: str, repo: str, pr_number: int, code_contexts: list[dict[str, str]]
-) -> Any:  # noqa: ANN401
+) -> Any:
     """Check if the function being optimized is being optimized again."""
     response = make_cfapi_request(
         "/is-already-optimized",

codeflash/benchmarking/codeflash_trace.py

@@ -108,7 +108,7 @@ def __call__(self, func: Callable) -> Callable:
         func_id = (func.__module__, func.__name__)
 
         @functools.wraps(func)
-        def wrapper(*args, **kwargs) -> Any:  # noqa: ANN002, ANN003, ANN401
+        def wrapper(*args, **kwargs) -> Any:  # noqa: ANN002, ANN003
             # Initialize thread-local active functions set if it doesn't exist
             if not hasattr(self._thread_local, "active_functions"):
                 self._thread_local.active_functions = set()

codeflash/benchmarking/instrument_codeflash_trace.py

@@ -53,7 +53,7 @@ def leave_FunctionDef(self, original_node: FunctionDef, updated_node: FunctionDe
 
         return updated_node
 
-    def leave_Module(self, original_node: cst.Module, updated_node: cst.Module) -> cst.Module:  # noqa: ARG002
+    def leave_Module(self, original_node: cst.Module, updated_node: cst.Module) -> cst.Module:
         # Create import statement for codeflash_trace
         if not self.added_codeflash_trace:
             return updated_node

codeflash/benchmarking/plugin/plugin.py

@@ -200,7 +200,7 @@ def get_benchmark_timings(trace_path: Path) -> dict[BenchmarkKey, int]:
 
     # Pytest hooks
     @pytest.hookimpl
-    def pytest_sessionfinish(self, session, exitstatus) -> None:  # noqa: ANN001, ARG002
+    def pytest_sessionfinish(self, session, exitstatus) -> None:  # noqa: ANN001
         """Execute after whole test run is completed."""
         # Write any remaining benchmark timings to the database
         codeflash_trace.close()
@@ -218,7 +218,7 @@ def pytest_collection_modifyitems(config: pytest.Config, items: list[pytest.Item
         skip_no_benchmark = pytest.mark.skip(reason="Test requires benchmark fixture")
         for item in items:
             # Check for direct benchmark fixture usage
-            has_fixture = hasattr(item, "fixturenames") and "benchmark" in item.fixturenames
+            has_fixture = hasattr(item, "fixturenames") and "benchmark" in item.fixturenames  # ty:ignore[unsupported-operator]
 
             # Check for @pytest.mark.benchmark marker
             has_marker = False
@@ -249,7 +249,7 @@ def wrapped_func(*args, **kwargs):  # noqa: ANN002, ANN003, ANN202
             self._run_benchmark(func)
             return wrapped_func
 
-        def _run_benchmark(self, func, *args, **kwargs):  # noqa: ANN001, ANN002, ANN003, ANN202
+        def _run_benchmark(self, func, *args, **kwargs):  # noqa: ANN002, ANN003, ANN202
             """Actual benchmark implementation."""
             node_path = getattr(self.request.node, "path", None) or getattr(self.request.node, "fspath", None)
             if node_path is None:

codeflash/cli_cmds/cli_common.py

@@ -43,7 +43,7 @@ def inquirer_wrapper(func: Callable[..., str | bool], *args: str | bool, **kwarg
     return func(*new_args, **new_kwargs)
 
 
-def split_string_to_cli_width(string: str, is_confirm: bool = False) -> list[str]:  # noqa: FBT001, FBT002
+def split_string_to_cli_width(string: str, is_confirm: bool = False) -> list[str]:
     cli_width, _ = shutil.get_terminal_size()
     # split string to lines that accommodate "[?] " prefix
     cli_width -= len("[?] ")

codeflash/cli_cmds/cmd_init.py

@@ -687,7 +687,7 @@ def create_empty_pyproject_toml(pyproject_toml_path: Path) -> None:
         apologize_and_exit()
 
 
-def install_github_actions(override_formatter_check: bool = False) -> None:  # noqa: FBT001, FBT002
+def install_github_actions(override_formatter_check: bool = False) -> None:
     try:
         config, _config_file_path = parse_config_file(override_formatter_check=override_formatter_check)
 
@@ -1121,11 +1121,12 @@ def install_github_actions(override_formatter_check: bool = False) -> None:  # n
         apologize_and_exit()
 
 
-def determine_dependency_manager(pyproject_data: dict[str, Any]) -> DependencyManager:  # noqa: PLR0911
+def determine_dependency_manager(pyproject_data: dict[str, Any]) -> DependencyManager:
     """Determine which dependency manager is being used based on pyproject.toml contents."""
-    if (Path.cwd() / "poetry.lock").exists():
+    cwd = Path.cwd()
+    if (cwd / "poetry.lock").exists():
         return DependencyManager.POETRY
-    if (Path.cwd() / "uv.lock").exists():
+    if (cwd / "uv.lock").exists():
         return DependencyManager.UV
     if "tool" not in pyproject_data:
         return DependencyManager.PIP
@@ -1325,10 +1326,7 @@ def collect_repo_files_for_workflow(git_root: Path) -> dict[str, Any]:
 
 
 def generate_dynamic_workflow_content(
-    optimize_yml_content: str,
-    config: tuple[dict[str, Any], Path],
-    git_root: Path,
-    benchmark_mode: bool = False,  # noqa: FBT001, FBT002
+    optimize_yml_content: str, config: tuple[dict[str, Any], Path], git_root: Path, benchmark_mode: bool = False
 ) -> str:
     """Generate workflow content with dynamic steps from AI service, falling back to static template.
 
@@ -1460,10 +1458,7 @@ def generate_dynamic_workflow_content(
 
 
 def customize_codeflash_yaml_content(
-    optimize_yml_content: str,
-    config: tuple[dict[str, Any], Path],
-    git_root: Path,
-    benchmark_mode: bool = False,  # noqa: FBT001, FBT002
+    optimize_yml_content: str, config: tuple[dict[str, Any], Path], git_root: Path, benchmark_mode: bool = False
 ) -> str:
     module_path = str(Path(config["module_root"]).relative_to(git_root) / "**")
     optimize_yml_content = optimize_yml_content.replace("{{ codeflash_module_path }}", module_path)

codeflash/code_utils/code_extractor.py

@@ -45,14 +45,14 @@ def visit_FunctionDef(self, node: cst.FunctionDef) -> Optional[bool]:
         self.scope_depth += 1
         return True
 
-    def leave_FunctionDef(self, original_node: cst.FunctionDef) -> None:  # noqa: ARG002
+    def leave_FunctionDef(self, original_node: cst.FunctionDef) -> None:
         self.scope_depth -= 1
 
-    def visit_ClassDef(self, node: cst.ClassDef) -> Optional[bool]:  # noqa: ARG002
+    def visit_ClassDef(self, node: cst.ClassDef) -> Optional[bool]:
         self.scope_depth += 1
         return True
 
-    def leave_ClassDef(self, original_node: cst.ClassDef) -> None:  # noqa: ARG002
+    def leave_ClassDef(self, original_node: cst.ClassDef) -> None:
         self.scope_depth -= 1
 
 
@@ -66,7 +66,7 @@ def __init__(self, new_functions: dict[str, cst.FunctionDef], new_function_order
         self.processed_functions: set[str] = set()
         self.scope_depth = 0
 
-    def visit_FunctionDef(self, node: cst.FunctionDef) -> None:  # noqa: ARG002
+    def visit_FunctionDef(self, node: cst.FunctionDef) -> None:
         self.scope_depth += 1
 
     def leave_FunctionDef(self, original_node: cst.FunctionDef, updated_node: cst.FunctionDef) -> cst.FunctionDef:
@@ -81,14 +81,14 @@ def leave_FunctionDef(self, original_node: cst.FunctionDef, updated_node: cst.Fu
             return self.new_functions[name]
         return updated_node
 
-    def visit_ClassDef(self, node: cst.ClassDef) -> None:  # noqa: ARG002
+    def visit_ClassDef(self, node: cst.ClassDef) -> None:
         self.scope_depth += 1
 
-    def leave_ClassDef(self, original_node: cst.ClassDef, updated_node: cst.ClassDef) -> cst.ClassDef:  # noqa: ARG002
+    def leave_ClassDef(self, original_node: cst.ClassDef, updated_node: cst.ClassDef) -> cst.ClassDef:
         self.scope_depth -= 1
         return updated_node
 
-    def leave_Module(self, original_node: cst.Module, updated_node: cst.Module) -> cst.Module:  # noqa: ARG002
+    def leave_Module(self, original_node: cst.Module, updated_node: cst.Module) -> cst.Module:
         # Add any new functions that weren't in the original file
         new_statements = list(updated_node.body)
 
@@ -142,28 +142,28 @@ def __init__(self) -> None:
         self.scope_depth = 0
         self.if_else_depth = 0
 
-    def visit_FunctionDef(self, node: cst.FunctionDef) -> Optional[bool]:  # noqa: ARG002
+    def visit_FunctionDef(self, node: cst.FunctionDef) -> Optional[bool]:
         self.scope_depth += 1
         return True
 
-    def leave_FunctionDef(self, original_node: cst.FunctionDef) -> None:  # noqa: ARG002
+    def leave_FunctionDef(self, original_node: cst.FunctionDef) -> None:
         self.scope_depth -= 1
 
-    def visit_ClassDef(self, node: cst.ClassDef) -> Optional[bool]:  # noqa: ARG002
+    def visit_ClassDef(self, node: cst.ClassDef) -> Optional[bool]:
         self.scope_depth += 1
         return True
 
-    def leave_ClassDef(self, original_node: cst.ClassDef) -> None:  # noqa: ARG002
+    def leave_ClassDef(self, original_node: cst.ClassDef) -> None:
         self.scope_depth -= 1
 
-    def visit_If(self, node: cst.If) -> Optional[bool]:  # noqa: ARG002
+    def visit_If(self, node: cst.If) -> Optional[bool]:
         self.if_else_depth += 1
         return True
 
-    def leave_If(self, original_node: cst.If) -> None:  # noqa: ARG002
+    def leave_If(self, original_node: cst.If) -> None:
         self.if_else_depth -= 1
 
-    def visit_Else(self, node: cst.Else) -> Optional[bool]:  # noqa: ARG002
+    def visit_Else(self, node: cst.Else) -> Optional[bool]:
         # Else blocks are already counted as part of the if statement
         return True
 
@@ -232,24 +232,24 @@ def __init__(self, new_assignments: dict[str, cst.Assign | cst.AnnAssign], new_a
         self.scope_depth = 0
         self.if_else_depth = 0
 
-    def visit_FunctionDef(self, node: cst.FunctionDef) -> None:  # noqa: ARG002
+    def visit_FunctionDef(self, node: cst.FunctionDef) -> None:
         self.scope_depth += 1
 
-    def leave_FunctionDef(self, original_node: cst.FunctionDef, updated_node: cst.FunctionDef) -> cst.FunctionDef:  # noqa: ARG002
+    def leave_FunctionDef(self, original_node: cst.FunctionDef, updated_node: cst.FunctionDef) -> cst.FunctionDef:
         self.scope_depth -= 1
         return updated_node
 
-    def visit_ClassDef(self, node: cst.ClassDef) -> None:  # noqa: ARG002
+    def visit_ClassDef(self, node: cst.ClassDef) -> None:
         self.scope_depth += 1
 
-    def leave_ClassDef(self, original_node: cst.ClassDef, updated_node: cst.ClassDef) -> cst.ClassDef:  # noqa: ARG002
+    def leave_ClassDef(self, original_node: cst.ClassDef, updated_node: cst.ClassDef) -> cst.ClassDef:
         self.scope_depth -= 1
         return updated_node
 
-    def visit_If(self, node: cst.If) -> None:  # noqa: ARG002
+    def visit_If(self, node: cst.If) -> None:
         self.if_else_depth += 1
 
-    def leave_If(self, original_node: cst.If, updated_node: cst.If) -> cst.If:  # noqa: ARG002
+    def leave_If(self, original_node: cst.If, updated_node: cst.If) -> cst.If:
         self.if_else_depth -= 1
         return updated_node
 
@@ -284,7 +284,7 @@ def leave_AnnAssign(self, original_node: cst.AnnAssign, updated_node: cst.AnnAss
 
         return updated_node
 
-    def leave_Module(self, original_node: cst.Module, updated_node: cst.Module) -> cst.Module:  # noqa: ARG002
+    def leave_Module(self, original_node: cst.Module, updated_node: cst.Module) -> cst.Module:
         # Add any new assignments that weren't in the original file
         new_statements = list(updated_node.body)
 
@@ -371,7 +371,7 @@ def __init__(self, global_statements: list[cst.SimpleStatementLine]) -> None:
         super().__init__()
         self.global_statements = global_statements
 
-    def leave_Module(self, original_node: cst.Module, updated_node: cst.Module) -> cst.Module:  # noqa: ARG002
+    def leave_Module(self, original_node: cst.Module, updated_node: cst.Module) -> cst.Module:
         if not self.global_statements:
             return updated_node
 
@@ -397,20 +397,20 @@ def __init__(self) -> None:
         self.global_statements = []
         self.in_function_or_class = False
 
-    def visit_ClassDef(self, node: cst.ClassDef) -> bool:  # noqa: ARG002
+    def visit_ClassDef(self, node: cst.ClassDef) -> bool:
         # Don't visit inside classes
         self.in_function_or_class = True
         return False
 
-    def leave_ClassDef(self, original_node: cst.ClassDef) -> None:  # noqa: ARG002
+    def leave_ClassDef(self, original_node: cst.ClassDef) -> None:
         self.in_function_or_class = False
 
-    def visit_FunctionDef(self, node: cst.FunctionDef) -> bool:  # noqa: ARG002
+    def visit_FunctionDef(self, node: cst.FunctionDef) -> bool:
         # Don't visit inside functions
         self.in_function_or_class = True
         return False
 
-    def leave_FunctionDef(self, original_node: cst.FunctionDef) -> None:  # noqa: ARG002
+    def leave_FunctionDef(self, original_node: cst.FunctionDef) -> None:
         self.in_function_or_class = False
 
     def visit_SimpleStatementLine(self, node: cst.SimpleStatementLine) -> None:
@@ -491,16 +491,16 @@ def visit_Module(self, node: cst.Module) -> None:
         self.depth = 0
         self._collect_imports_from_block(node)
 
-    def visit_FunctionDef(self, node: cst.FunctionDef) -> None:  # noqa: ARG002
+    def visit_FunctionDef(self, node: cst.FunctionDef) -> None:
         self.depth += 1
 
-    def leave_FunctionDef(self, node: cst.FunctionDef) -> None:  # noqa: ARG002
+    def leave_FunctionDef(self, node: cst.FunctionDef) -> None:
         self.depth -= 1
 
-    def visit_ClassDef(self, node: cst.ClassDef) -> None:  # noqa: ARG002
+    def visit_ClassDef(self, node: cst.ClassDef) -> None:
         self.depth += 1
 
-    def leave_ClassDef(self, node: cst.ClassDef) -> None:  # noqa: ARG002
+    def leave_ClassDef(self, node: cst.ClassDef) -> None:
         self.depth -= 1
 
     def visit_If(self, node: cst.If) -> None:
@@ -530,9 +530,7 @@ def find_last_import_line(target_code: str) -> int:
 
 class FutureAliasedImportTransformer(cst.CSTTransformer):
     def leave_ImportFrom(
-        self,
-        original_node: cst.ImportFrom,  # noqa: ARG002
-        updated_node: cst.ImportFrom,
+        self, original_node: cst.ImportFrom, updated_node: cst.ImportFrom
     ) -> cst.BaseSmallStatement | cst.FlattenSentinel[cst.BaseSmallStatement] | cst.RemovalSentinel:
         import libcst.matchers as m
 
@@ -677,7 +675,7 @@ def resolve_star_import(module_name: str, project_root: Path) -> set[str]:
                     if not name.startswith("_"):
                         public_names.add(name)
 
-        return public_names  # noqa: TRY300
+        return public_names
 
     except Exception as e:
         logger.warning(f"Error resolving star import for {module_name}: {e}")
@@ -1166,7 +1164,7 @@ def _is_target_function_call(self, node: ast.Call) -> bool:
 
         return False
 
-    def _get_call_name(self, func_node) -> Optional[str]:  # noqa: ANN001
+    def _get_call_name(self, func_node) -> Optional[str]:
         """Extract the name being called from a function node."""
         # Fast path short-circuit for ast.Name nodes
         if isinstance(func_node, ast.Name):
@@ -1559,10 +1557,7 @@ def is_numerical_code(code_string: str, function_name: str | None = None) -> boo
 
     # If numba is not installed and all modules used require numba for optimization,
     # return False since we can't optimize this code
-    if not has_numba and modules_used.issubset(NUMBA_REQUIRED_MODULES):  # noqa : SIM103
-        return False
-
-    return True
+    return not (not has_numba and modules_used.issubset(NUMBA_REQUIRED_MODULES))
 
 
 def get_opt_review_metrics(

codeflash/code_utils/code_utils.py

@@ -166,7 +166,7 @@ def filter_args(addopts_args: list[str]) -> list[str]:
     return filtered_args
 
 
-def modify_addopts(config_file: Path) -> tuple[str, bool]:  # noqa : PLR0911
+def modify_addopts(config_file: Path) -> tuple[str, bool]:
     file_type = config_file.suffix.lower()
     filename = config_file.name
     config = None