remove ignored linting issues

Author: Saga4

codeflash/api/aiservice.py

@@ -253,7 +253,7 @@ def optimize_python_code_line_profiler(  # noqa: D417
         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,
     ) -> list[OptimizedCandidate]:
         """Optimize the given python code for performance using line profiler results.
 
@@ -646,7 +646,7 @@ def generate_regression_tests(  # noqa: D417
         test_timeout: int,
         trace_id: str,
         test_index: int,
-        is_numerical_code: bool | None = None,  # noqa: FBT001
+        is_numerical_code: bool | None = None,
     ) -> tuple[str, str, str] | None:
         """Generate regression tests for the given function by making a request to the Django endpoint.
 
@@ -706,7 +706,7 @@ def generate_regression_tests(  # noqa: D417
             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})
@@ -722,7 +722,7 @@ def get_optimization_review(
         function_trace_id: str,
         coverage_message: str,
         replay_tests: str,
-        concolic_tests: str,  # noqa: ARG002
+        concolic_tests: str,
         calling_fn_details: str,
     ) -> OptimizationReviewResult:
         """Compute the optimization review of current Pull Request.

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().
@@ -376,7 +376,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

@@ -110,7 +110,7 @@ def get_function_benchmark_timings(trace_path: Path) -> dict[str, dict[Benchmark
 
             # Process each row
             for row in cursor.fetchall():
-                module_name, class_name, function_name, benchmark_file, benchmark_func, benchmark_line, time_ns = row
+                module_name, class_name, function_name, benchmark_file, benchmark_func, _benchmark_line, time_ns = row
 
                 # Create the function key (module_name.class_name.function_name)
                 if class_name:
@@ -172,7 +172,7 @@ def get_benchmark_timings(trace_path: Path) -> dict[BenchmarkKey, int]:
 
             # Process overhead information
             for row in cursor.fetchall():
-                benchmark_file, benchmark_func, benchmark_line, total_overhead_ns = row
+                benchmark_file, benchmark_func, _benchmark_line, total_overhead_ns = row
                 benchmark_key = BenchmarkKey(module_path=benchmark_file, function_name=benchmark_func)
                 overhead_by_benchmark[benchmark_key] = total_overhead_ns or 0  # Handle NULL sum case
 
@@ -184,7 +184,7 @@ def get_benchmark_timings(trace_path: Path) -> dict[BenchmarkKey, int]:
 
             # Process each row and subtract overhead
             for row in cursor.fetchall():
-                benchmark_file, benchmark_func, benchmark_line, time_ns = row
+                benchmark_file, benchmark_func, _benchmark_line, time_ns = row
 
                 # Create the benchmark key (file::function::line)
                 benchmark_key = BenchmarkKey(module_path=benchmark_file, function_name=benchmark_func)
@@ -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:
         """Execute after whole test run is completed."""
         # Write any remaining benchmark timings to the database
         codeflash_trace.close()
@@ -236,7 +236,7 @@ class Benchmark:  # noqa: D106
         def __init__(self, request: pytest.FixtureRequest) -> None:
             self.request = request
 
-        def __call__(self, func, *args, **kwargs):  # type: ignore  # noqa: ANN001, ANN002, ANN003, ANN204, PGH003
+        def __call__(self, func, *args, **kwargs):  # type: ignore  # noqa: ANN002, ANN003, ANN204, PGH003
             """Handle both direct function calls and decorator usage."""
             if args or kwargs:
                 # Used as benchmark(func, *args, **kwargs)
@@ -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

@@ -663,7 +663,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)
 
@@ -1089,7 +1089,7 @@ 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():
         return DependencyManager.POETRY
@@ -1251,10 +1251,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.
 
@@ -1378,10 +1375,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

@@ -36,28 +36,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
 
@@ -111,24 +111,24 @@ def __init__(self, new_assignments: dict[str, cst.Assign], new_assignment_order:
         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
 
@@ -150,7 +150,7 @@ def leave_Assign(self, original_node: cst.Assign, updated_node: cst.Assign) -> c
 
         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)
 
@@ -194,20 +194,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:
@@ -288,16 +288,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:
@@ -320,9 +320,7 @@ def __init__(self, global_statements: list[cst.SimpleStatementLine], last_import
         self.inserted = False
 
     def leave_SimpleStatementLine(
-        self,
-        original_node: cst.SimpleStatementLine,  # noqa: ARG002
-        updated_node: cst.SimpleStatementLine,
+        self, original_node: cst.SimpleStatementLine, updated_node: cst.SimpleStatementLine
     ) -> cst.Module:
         self.current_line += 1
 
@@ -333,7 +331,7 @@ def leave_SimpleStatementLine(
 
         return cst.Module(body=[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:
         # If there were no imports, add at the beginning of the module
         if self.last_import_line == 0 and not self.inserted:
             updated_body = list(updated_node.body)
@@ -361,9 +359,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
 
@@ -484,7 +480,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}")
@@ -973,7 +969,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):
@@ -1363,7 +1359,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
+    if not has_numba and modules_used.issubset(NUMBA_REQUIRED_MODULES):
         return False
 
     return True