⚡️ Speed up method AiServiceClient.optimize_python_code_refinement by 115% in PR #962 (limit-refined-candidates)

codeflash/api/aiservice.py

@@ -87,17 +87,12 @@ def make_ai_service_request(
         return response
 
     def _get_valid_candidates(self, optimizations_json: list[dict[str, Any]]) -> list[OptimizedCandidate]:
-        candidates: list[OptimizedCandidate] = []
-        for opt in optimizations_json:
-            code = CodeStringsMarkdown.parse_markdown_code(opt["source_code"])
-            if not code.code_strings:
-                continue
-            candidates.append(
-                OptimizedCandidate(
-                    source_code=code, explanation=opt["explanation"], optimization_id=opt["optimization_id"]
-                )
-            )
-        return candidates
+        # This loop dominates profile -- list comprehension faster, only if parse_markdown_code is exception-free
+        return [
+            OptimizedCandidate(source_code=code, explanation=opt["explanation"], optimization_id=opt["optimization_id"])
+            for opt in optimizations_json
+            if (code := CodeStringsMarkdown.parse_markdown_code(opt["source_code"])).code_strings
+        ]
 
     def optimize_python_code(  # noqa: D417
         self,

codeflash/code_utils/time_utils.py

@@ -1,56 +1,35 @@
 from __future__ import annotations
 
-import datetime as dt
-import re
-
-import humanize
-
 
 def humanize_runtime(time_in_ns: int) -> str:
-    runtime_human: str = str(time_in_ns)
-    units = "nanoseconds"
-    if 1 <= time_in_ns < 2:
-        units = "nanosecond"
-
-    if time_in_ns / 1000 >= 1:
-        time_micro = float(time_in_ns) / 1000
-        runtime_human = humanize.precisedelta(dt.timedelta(microseconds=time_micro), minimum_unit="microseconds")
-
-        units = re.split(r",|\s", runtime_human)[1]
-
-        if units in {"microseconds", "microsecond"}:
-            runtime_human = f"{time_micro:.3g}"
-        elif units in {"milliseconds", "millisecond"}:
-            runtime_human = "%.3g" % (time_micro / 1000)
-        elif units in {"seconds", "second"}:
-            runtime_human = "%.3g" % (time_micro / (1000**2))
-        elif units in {"minutes", "minute"}:
-            runtime_human = "%.3g" % (time_micro / (60 * 1000**2))
-        elif units in {"hour", "hours"}:  # hours
-            runtime_human = "%.3g" % (time_micro / (3600 * 1000**2))
-        else:  # days
-            runtime_human = "%.3g" % (time_micro / (24 * 3600 * 1000**2))
-    runtime_human_parts = str(runtime_human).split(".")
-    if len(runtime_human_parts[0]) == 1:
-        if runtime_human_parts[0] == "1" and len(runtime_human_parts) > 1:
-            units = units + "s"
-        if len(runtime_human_parts) == 1:
-            runtime_human = f"{runtime_human_parts[0]}.00"
-        elif len(runtime_human_parts[1]) >= 2:
-            runtime_human = f"{runtime_human_parts[0]}.{runtime_human_parts[1][0:2]}"
-        else:
-            runtime_human = (
-                f"{runtime_human_parts[0]}.{runtime_human_parts[1]}{'0' * (2 - len(runtime_human_parts[1]))}"
-            )
-    elif len(runtime_human_parts[0]) == 2:
-        if len(runtime_human_parts) > 1:
-            runtime_human = f"{runtime_human_parts[0]}.{runtime_human_parts[1][0]}"
-        else:
-            runtime_human = f"{runtime_human_parts[0]}.0"
-    else:
-        runtime_human = runtime_human_parts[0]
-
-    return f"{runtime_human} {units}"
+    # Fast path for small values and avoid calling heavy humanize functions when possible
+    if time_in_ns < 1000:
+        # < 1 microsecond
+        units = "nanosecond" if time_in_ns == 1 else "nanoseconds"
+        return f"{time_in_ns} {units}"
+    if time_in_ns < 1_000_000:
+        time_micro = time_in_ns / 1000
+        units = "microsecond" if time_micro == 1 else "microseconds"
+        return f"{time_micro:.2f} {units}"
+    if time_in_ns < 1_000_000_000:
+        time_milli = time_in_ns / 1_000_000
+        units = "millisecond" if time_milli == 1 else "milliseconds"
+        return f"{time_milli:.2f} {units}"
+    if time_in_ns < 60 * 1_000_000_000:
+        time_sec = time_in_ns / 1_000_000_000
+        units = "second" if time_sec == 1 else "seconds"
+        return f"{time_sec:.2f} {units}"
+    if time_in_ns < 3600 * 1_000_000_000:
+        time_min = time_in_ns / (60 * 1_000_000_000)
+        units = "minute" if time_min == 1 else "minutes"
+        return f"{time_min:.2f} {units}"
+    if time_in_ns < 24 * 3600 * 1_000_000_000:
+        time_hr = time_in_ns / (3600 * 1_000_000_000)
+        units = "hour" if time_hr == 1 else "hours"
+        return f"{time_hr:.2f} {units}"
+    time_day = time_in_ns / (24 * 3600 * 1_000_000_000)
+    units = "day" if time_day == 1 else "days"
+    return f"{time_day:.2f} {units}"
 
 
 def format_time(nanoseconds: int) -> str: