From c728715ab07303a61f7f22e9d454f8e0bbc0d185 Mon Sep 17 00:00:00 2001
From: "codeflash-ai[bot]"
 <148906541+codeflash-ai[bot]@users.noreply.github.com>
Date: Sat, 7 Feb 2026 14:01:12 +0000
Subject: [PATCH] Optimize _str_to_version_tuple
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The optimized code achieves a **26% runtime improvement** (428μs → 340μs) by eliminating expensive operations in the version tuple construction path.

## Key Optimizations

**1. Direct tuple construction instead of generator expression**
- **Original**: `tuple(int(v) for v in [res.group("major"), res.group("minor"), res.group("patch")])`
- **Optimized**: `_int(major_s), _int(minor_s), _int(patch_s) = res.groups()` followed by `return (_int(major_s), _int(minor_s), _int(patch_s))`

This change eliminates:
- Generator object creation and iteration overhead
- Three separate `res.group()` calls (replaced with single `res.groups()` call)
- List allocation for the three group names
- Generator-to-tuple conversion overhead

**2. Local binding of `int` builtin**
- `_int = int` caches the global `int` lookup as a local variable
- Python resolves local variables faster than global builtins (LOAD_FAST vs LOAD_GLOBAL bytecode)
- Saves 3 global lookups per function call

## Performance Impact

The line profiler shows the critical line improvement:
- **Original**: 1.65ms (62.8% of total time) for the tuple generation line
- **Optimized**: 0.77ms (combined time for groups() + tuple construction, ~45% of total time)

## Test Results Analysis

The optimization shows **consistent 40-70% speedup** across valid version parsing cases:
- Simple versions like "1.2.3": **53-54% faster** (5.5μs → 3.6μs)
- Edge cases with zeros/leading zeros: **46-65% faster**
- Large numbers: **41-46% faster**
- Invalid inputs: Minimal overhead, ~0-4% faster (error path unchanged)

## Impact on Workloads

Based on `function_references`, this function is called in `__post_init__` of what appears to be a Version class. This means:
- **Every version object instantiation** will benefit from this 26% speedup
- In dataset loading workflows with many version checks, this compounds significantly
- The optimization is particularly valuable if version parsing occurs in loops or bulk operations (as suggested by the 300-item test case showing consistent gains)

The optimization maintains identical behavior for all inputs while substantially reducing execution time for the common case of valid version strings, with negligible impact on error cases.
---
 src/datasets/utils/version.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/datasets/utils/version.py b/src/datasets/utils/version.py
index 75cf4c39d5f..4591c4574f6 100644
--- a/src/datasets/utils/version.py
+++ b/src/datasets/utils/version.py
@@ -98,7 +98,9 @@ def _str_to_version_tuple(version_str):
     res = _VERSION_REG.match(version_str)
     if not res:
         raise ValueError(f"Invalid version '{version_str}'. Format should be x.y.z with {{x,y,z}} being digits.")
-    return tuple(int(v) for v in [res.group("major"), res.group("minor"), res.group("patch")])
+    _int = int
+    major_s, minor_s, patch_s = res.groups()
+    return (_int(major_s), _int(minor_s), _int(patch_s))
 
 
 def _version_tuple_to_str(version_tuple):