fix: resolve all linting issues from ruff and mypy

Fixed ruff issues:
- PLW0108: Removed unnecessary lambda wrappers, inline method references
  - Changed lambda: self.future_all_code_repair.clear() to self.future_all_code_repair.clear
  - Changed lambda: self.future_adaptive_optimizations.clear() to self.future_adaptive_optimizations.clear
- PTH123: Replaced open() with Path.open() for debug file
- S108: Use get_run_tmp_file() instead of hardcoded /tmp path for security
- RUF059: Prefix unused concolic_tests variable with underscore

Fixed mypy issues in PrComment.py:
- Renamed loop variable from 'result' to 'test_result' to avoid redefinition
- Removed str() conversion for async throughput values (already int type)
- Type annotations now match actual value types

All files formatted with ruff format.

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

Author: mohammedahmed18

codeflash/github/PrComment.py

@@ -26,10 +26,10 @@ class PrComment:
 
     def to_json(self) -> dict[str, Union[str, int, dict[str, dict[str, int]], list[BenchmarkDetail], None]]:
         report_table: dict[str, dict[str, int]] = {}
-        for test_type, result in self.winning_behavior_test_results.get_test_pass_fail_report_by_type().items():
+        for test_type, test_result in self.winning_behavior_test_results.get_test_pass_fail_report_by_type().items():
             name = test_type.to_name()
             if name:
-                report_table[name] = result
+                report_table[name] = test_result
 
         result: dict[str, Union[str, int, dict[str, dict[str, int]], list[BenchmarkDetail], None]] = {
             "optimization_explanation": self.optimization_explanation,
@@ -45,8 +45,8 @@ def to_json(self) -> dict[str, Union[str, int, dict[str, dict[str, int]], list[B
         }
 
         if self.original_async_throughput is not None and self.best_async_throughput is not None:
-            result["original_async_throughput"] = str(self.original_async_throughput)
-            result["best_async_throughput"] = str(self.best_async_throughput)
+            result["original_async_throughput"] = self.original_async_throughput
+            result["best_async_throughput"] = self.best_async_throughput
 
         return result
 

codeflash/optimization/function_optimizer.py

@@ -311,14 +311,12 @@ def _handle_empty_queue(self) -> CandidateNode | None:
                 lambda: setattr(self, "line_profiler_done", True),
             )
         if len(self.future_all_code_repair) > 0:
-            result = self._process_candidates(
+            return self._process_candidates(
                 self.future_all_code_repair,
                 "Repairing {0} candidates",
                 "Added {0} candidates from repair, total candidates now: {1}",
-                None,
+                self.future_all_code_repair.clear,
             )
-            self.future_all_code_repair.clear()
-            return result
         if self.line_profiler_done and not self.refinement_done:
             return self._process_candidates(
                 self.future_all_refinements,
@@ -328,14 +326,12 @@ def _handle_empty_queue(self) -> CandidateNode | None:
                 filter_candidates_func=self._filter_refined_candidates,
             )
         if len(self.future_adaptive_optimizations) > 0:
-            result = self._process_candidates(
+            return self._process_candidates(
                 self.future_adaptive_optimizations,
                 "Applying adaptive optimizations to {0} candidates",
                 "Added {0} candidates from adaptive optimization, total candidates now: {1}",
-                None,
+                self.future_adaptive_optimizations.clear,
             )
-            self.future_adaptive_optimizations.clear()
-            return result
         return None  # All done
 
     def _process_candidates(
@@ -600,11 +596,10 @@ def generate_and_instrument_tests(
             logger.debug(f"[PIPELINE] Wrote behavioral test to {generated_test.behavior_file_path}")
 
             # Save perf test source for debugging
-            from pathlib import Path
-
-            debug_path = Path("/tmp/codeflash_perf_test_debug.test.ts")  # noqa: S108
-            debug_path.write_text(generated_test.instrumented_perf_test_source, encoding="utf-8")
-            logger.warning("[PERF DEBUG] Saved perf test to /tmp/codeflash_perf_test_debug.test.ts for inspection")
+            debug_file_path = get_run_tmp_file(Path("perf_test_debug.test.ts"))
+            with debug_file_path.open("w", encoding="utf-8") as debug_f:
+                debug_f.write(generated_test.instrumented_perf_test_source)
+            logger.warning(f"[PERF DEBUG] Saved perf test to {debug_file_path} for inspection")
 
             with generated_test.perf_file_path.open("w", encoding="utf8") as f:
                 f.write(generated_test.instrumented_perf_test_source)
@@ -2104,7 +2099,7 @@ def process_review(
             formatted_generated_test = format_generated_code(concolic_test_str, self.args.formatter_cmds)
             generated_tests_str += f"```{code_lang}\n{formatted_generated_test}\n```\n\n"
 
-        existing_tests, replay_tests, _ = existing_tests_source_for(
+        existing_tests, replay_tests, _concolic_tests = existing_tests_source_for(
             self.function_to_optimize.qualified_name_with_modules_from_root(self.project_root),
             function_to_all_tests,
             test_cfg=self.test_cfg,