Skip to content

⚡️ Speed up function convert_unix_timestamp by 11% - #4

Open
codeflash-ai[bot] wants to merge 1 commit into
mainfrom
codeflash/optimize-convert_unix_timestamp-mgzqzpf1
Open

⚡️ Speed up function convert_unix_timestamp by 11%#4
codeflash-ai[bot] wants to merge 1 commit into
mainfrom
codeflash/optimize-convert_unix_timestamp-mgzqzpf1

Conversation

@codeflash-ai

@codeflash-ai codeflash-ai Bot commented Oct 20, 2025

Copy link
Copy Markdown

📄 11% (0.11x) speedup for convert_unix_timestamp in src/together/utils/tools.py

⏱️ Runtime : 9.92 milliseconds → 8.96 milliseconds (best of 128 runs)

📝 Explanation and details

The optimization replaces the expensive strftime() method call with direct f-string formatting using datetime object attributes. Instead of dt_object.strftime("%Y-%m-%dT%H:%M:%S.%fZ"), the code now uses f"{dt_object.year:04d}-{dt_object.month:02d}-{dt_object.day:02d}T{dt_object.hour:02d}:{dt_object.minute:02d}:{dt_object.second:02d}.{dt_object.microsecond:06d}Z".

This provides a 10% overall speedup because:

  • Eliminates format string parsing: strftime() must parse the format string "%Y-%m-%dT%H:%M:%S.%fZ" at runtime, while f-strings are compiled at parse time
  • Direct attribute access: Accessing dt_object.year, dt_object.month, etc. is faster than the internal formatting logic in strftime()
  • Reduced function call overhead: f-string formatting avoids the method call to strftime()

The line profiler shows the original strftime() line consumed 73.4% of execution time (10.3ms out of 14.0ms total), making it the clear bottleneck. The optimized version spreads this work across multiple f-string operations that are collectively faster.

Test case performance: The optimization shows consistent 30-60% speedup across individual test cases, with particularly strong gains (60-78%) on simple cases like epoch and basic timestamps. Even large-scale tests with 1000 iterations show 9-13% improvements, demonstrating the optimization scales well for batch processing scenarios.

✅ Correctness verification report:

Test Status
⚙️ Existing Unit Tests 🔘 None Found
🌀 Generated Regression Tests ✅ 6033 Passed
⏪ Replay Tests 🔘 None Found
🔎 Concolic Coverage Tests ✅ 1 Passed
📊 Tests Coverage 100.0%
🌀 Generated Regression Tests and Runtime 
from __future__ import annotations

from datetime import datetime, timedelta, timezone

# imports
import pytest
from together.utils.tools import convert_unix_timestamp

# unit tests

# 1. Basic Test Cases

def test_basic_epoch():
    # Test the Unix epoch (0)
    codeflash_output = convert_unix_timestamp(0) # 6.74μs -> 4.00μs (68.2% faster)

def test_basic_recent_time():
    # Test a recent date: 2024-01-01 00:00:00 UTC
    ts = 1704067200
    expected = "2024-01-01T00:00:00.000000Z"
    codeflash_output = convert_unix_timestamp(ts) # 6.00μs -> 3.59μs (67.3% faster)

def test_basic_noon_time():
    # Test a time at noon: 2022-05-15 12:00:00 UTC
    ts = 1652616000
    expected = "2022-05-15T12:00:00.000000Z"
    codeflash_output = convert_unix_timestamp(ts) # 5.68μs -> 3.65μs (55.5% faster)

def test_basic_microseconds():
    # Test a timestamp with microsecond precision (should always end with .000000Z)
    ts = 1234567890
    expected = "2009-02-13T23:31:30.000000Z"
    codeflash_output = convert_unix_timestamp(ts) # 5.45μs -> 3.57μs (52.7% faster)

# 2. Edge Test Cases

def test_edge_negative_timestamp():
    # Test a negative timestamp (before 1970-01-01)
    ts = -1  # 1969-12-31 23:59:59 UTC
    expected = "1969-12-31T23:59:59.000000Z"
    codeflash_output = convert_unix_timestamp(ts) # 5.37μs -> 3.58μs (49.7% faster)

def test_edge_far_future():
    # Test a far future timestamp: 3000-01-01 00:00:00 UTC
    ts = 32503680000
    expected = "3000-01-01T00:00:00.000000Z"
    codeflash_output = convert_unix_timestamp(ts) # 5.45μs -> 3.45μs (57.8% faster)

def test_edge_far_past():
    # Test a far past timestamp: 1900-01-01 00:00:00 UTC
    ts = -2208988800
    expected = "1900-01-01T00:00:00.000000Z"
    codeflash_output = convert_unix_timestamp(ts) # 5.34μs -> 3.48μs (53.6% faster)

def test_edge_leap_second():
    # Leap seconds are not represented in Unix time, but test the second before a known leap second
    # 2016-12-31 23:59:59 UTC (before 2017 leap second)
    ts = 1483228799
    expected = "2016-12-31T23:59:59.000000Z"
    codeflash_output = convert_unix_timestamp(ts) # 5.14μs -> 3.45μs (48.7% faster)

def test_edge_dst_transition():
    # DST transitions are not in UTC, but test a timestamp around a typical DST change
    # 2021-03-14 02:00:00 UTC (US DST starts)
    ts = 1615687200
    expected = "2021-03-14T02:00:00.000000Z"
    codeflash_output = convert_unix_timestamp(ts) # 5.05μs -> 3.35μs (50.8% faster)

def test_edge_large_integer():
    # Test a very large integer within datetime range
    ts = 253402300799  # 9999-12-31T23:59:59 UTC
    expected = "9999-12-31T23:59:59.000000Z"
    codeflash_output = convert_unix_timestamp(ts) # 5.05μs -> 3.29μs (53.5% faster)


def test_edge_fractional_seconds_truncation():
    # Unix timestamps are integers, so microseconds should always be .000000
    ts = 1609459200  # 2021-01-01T00:00:00 UTC
    codeflash_output = convert_unix_timestamp(ts); result = codeflash_output # 10.6μs -> 5.94μs (78.3% faster)

def test_edge_type_error():
    # Non-integer input should raise a TypeError or ValueError
    with pytest.raises(TypeError):
        convert_unix_timestamp("not an int")
    with pytest.raises(TypeError):
        convert_unix_timestamp(None)
    with pytest.raises(TypeError):
        convert_unix_timestamp(3.1415)

# 3. Large Scale Test Cases

def test_large_scale_sequential_range():
    # Test a range of 1000 sequential timestamps (from 2000-01-01)
    base_ts = 946684800  # 2000-01-01T00:00:00 UTC
    for i in range(1000):
        ts = base_ts + i
        expected_dt = datetime.fromtimestamp(ts)
        expected = expected_dt.strftime("%Y-%m-%dT%H:%M:%S.%fZ")
        codeflash_output = convert_unix_timestamp(ts) # 1.62ms -> 1.48ms (9.43% faster)

def test_large_scale_random_selection():
    # Test 1000 randomly selected timestamps between 1970 and 2100
    import random
    random.seed(42)
    for _ in range(1000):
        ts = random.randint(0, 4102444800)  # up to 2100-01-01
        expected_dt = datetime.fromtimestamp(ts)
        expected = expected_dt.strftime("%Y-%m-%dT%H:%M:%S.%fZ")
        codeflash_output = convert_unix_timestamp(ts) # 1.65ms -> 1.52ms (9.16% faster)

def test_large_scale_negative_range():
    # Test 1000 negative timestamps (before 1970-01-01)
    for i in range(1000):
        ts = -i
        expected_dt = datetime.fromtimestamp(ts)
        expected = expected_dt.strftime("%Y-%m-%dT%H:%M:%S.%fZ")
        codeflash_output = convert_unix_timestamp(ts) # 1.59ms -> 1.45ms (9.51% faster)

def test_large_scale_performance():
    # Test that 1000 conversions do not take excessively long (rudimentary performance check)
    import time
    start = time.time()
    for i in range(1000):
        ts = 1609459200 + i  # 2021-01-01T00:00:00 UTC and onward
        convert_unix_timestamp(ts) # 1.63ms -> 1.43ms (13.5% faster)
    end = time.time()
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from __future__ import annotations

from datetime import datetime, timedelta, timezone

# imports
import pytest  # used for our unit tests
from together.utils.tools import convert_unix_timestamp

# unit tests

# ---------------------------
# Basic Test Cases
# ---------------------------

def test_basic_epoch():
    # Test the Unix epoch (0)
    codeflash_output = convert_unix_timestamp(0); result = codeflash_output # 7.41μs -> 4.60μs (61.0% faster)
    expected = datetime.fromtimestamp(0).strftime("%Y-%m-%dT%H:%M:%S.%fZ")

def test_basic_recent_date():
    # Test a recent known timestamp (e.g., 2023-01-01T00:00:00 UTC)
    ts = 1672531200  # 2023-01-01T00:00:00 UTC
    codeflash_output = convert_unix_timestamp(ts); result = codeflash_output # 4.36μs -> 3.32μs (31.1% faster)
    expected = datetime.fromtimestamp(ts).strftime("%Y-%m-%dT%H:%M:%S.%fZ")

def test_basic_midnight():
    # Test a timestamp at midnight
    dt = datetime(2022, 6, 1, 0, 0, 0)
    ts = int(dt.timestamp())
    codeflash_output = convert_unix_timestamp(ts); result = codeflash_output # 4.12μs -> 3.03μs (36.1% faster)
    expected = dt.strftime("%Y-%m-%dT%H:%M:%S.%fZ")

def test_basic_noon():
    # Test a timestamp at noon
    dt = datetime(2022, 6, 1, 12, 0, 0)
    ts = int(dt.timestamp())
    codeflash_output = convert_unix_timestamp(ts); result = codeflash_output # 4.40μs -> 3.24μs (35.8% faster)
    expected = dt.strftime("%Y-%m-%dT%H:%M:%S.%fZ")

def test_basic_microsecond_precision():
    # Test that microseconds are always present (should be .000000 if not in input)
    dt = datetime(2022, 6, 1, 12, 0, 0)
    ts = int(dt.timestamp())
    codeflash_output = convert_unix_timestamp(ts); result = codeflash_output # 4.20μs -> 3.07μs (36.6% faster)

# ---------------------------
# Edge Test Cases
# ---------------------------

def test_edge_before_epoch():
    # Test a negative timestamp (before 1970-01-01)
    ts = -1  # 1969-12-31T23:59:59 UTC
    codeflash_output = convert_unix_timestamp(ts); result = codeflash_output # 4.72μs -> 3.32μs (42.0% faster)
    expected = datetime.fromtimestamp(ts).strftime("%Y-%m-%dT%H:%M:%S.%fZ")

def test_edge_far_past():
    # Test a very old date (e.g., 1900-01-01)
    dt = datetime(1900, 1, 1, 0, 0, 0)
    ts = int(dt.timestamp())
    codeflash_output = convert_unix_timestamp(ts); result = codeflash_output # 4.57μs -> 3.21μs (42.3% faster)
    expected = dt.strftime("%Y-%m-%dT%H:%M:%S.%fZ")

def test_edge_far_future():
    # Test a date far in the future (e.g., 2100-01-01)
    dt = datetime(2100, 1, 1, 0, 0, 0)
    ts = int(dt.timestamp())
    codeflash_output = convert_unix_timestamp(ts); result = codeflash_output # 4.35μs -> 3.19μs (36.1% faster)
    expected = dt.strftime("%Y-%m-%dT%H:%M:%S.%fZ")

def test_edge_leap_year():
    # Test a leap year date (e.g., 2020-02-29)
    dt = datetime(2020, 2, 29, 12, 34, 56)
    ts = int(dt.timestamp())
    codeflash_output = convert_unix_timestamp(ts); result = codeflash_output # 4.27μs -> 3.13μs (36.5% faster)
    expected = dt.strftime("%Y-%m-%dT%H:%M:%S.%fZ")

def test_edge_dst_transition():
    # Test a timestamp during a DST transition (may be local time, but function uses local time)
    # Use a known DST transition for US (e.g., 2022-03-13 02:00:00 in US/Eastern)
    # Since fromtimestamp uses local time, this test is mostly to ensure no crash
    ts = 1647158400  # 2022-03-13T07:00:00 UTC
    codeflash_output = convert_unix_timestamp(ts); result = codeflash_output # 4.47μs -> 3.33μs (34.4% faster)
    expected = datetime.fromtimestamp(ts).strftime("%Y-%m-%dT%H:%M:%S.%fZ")

def test_edge_large_integer():
    # Test with a very large integer timestamp (close to datetime.max)
    dt = datetime(9999, 12, 31, 23, 59, 59)
    ts = int(dt.timestamp())
    codeflash_output = convert_unix_timestamp(ts); result = codeflash_output # 4.36μs -> 3.15μs (38.6% faster)
    expected = dt.strftime("%Y-%m-%dT%H:%M:%S.%fZ")



def test_edge_string_input():
    # Test with a string timestamp (should error)
    ts = "1672531200"
    with pytest.raises(TypeError):
        convert_unix_timestamp(ts) # 2.14μs -> 1.95μs (10.2% faster)

def test_edge_none_input():
    # Test with None as input (should error)
    with pytest.raises(TypeError):
        convert_unix_timestamp(None) # 1.39μs -> 1.40μs (0.643% slower)

# ---------------------------
# Large Scale Test Cases
# ---------------------------

def test_large_scale_sequential():
    # Test a sequence of 1000 consecutive timestamps
    base_ts = 1672531200  # 2023-01-01T00:00:00
    for i in range(1000):
        ts = base_ts + i
        codeflash_output = convert_unix_timestamp(ts); result = codeflash_output # 1.62ms -> 1.48ms (9.24% faster)
        expected = datetime.fromtimestamp(ts).strftime("%Y-%m-%dT%H:%M:%S.%fZ")

def test_large_scale_random():
    # Test 1000 random timestamps between 1970 and 2100
    import random
    start_ts = int(datetime(1970, 1, 1).timestamp())
    end_ts = int(datetime(2100, 1, 1).timestamp())
    random_ts_list = random.sample(range(start_ts, end_ts), 1000)
    for ts in random_ts_list:
        codeflash_output = convert_unix_timestamp(ts); result = codeflash_output # 1.66ms -> 1.50ms (10.8% faster)
        expected = datetime.fromtimestamp(ts).strftime("%Y-%m-%dT%H:%M:%S.%fZ")

def test_large_scale_extremes():
    # Test the function with a mix of min, max, and middle timestamps
    timestamps = [
        0,  # epoch
        int(datetime(1900, 1, 1, 0, 0, 0).timestamp()),
        int(datetime(1970, 1, 1, 0, 0, 0).timestamp()),
        int(datetime(2000, 1, 1, 0, 0, 0).timestamp()),
        int(datetime(2100, 1, 1, 0, 0, 0).timestamp()),
        int(datetime(9999, 12, 31, 23, 59, 59).timestamp())
    ]
    for ts in timestamps:
        codeflash_output = convert_unix_timestamp(ts); result = codeflash_output # 15.7μs -> 12.3μs (27.6% faster)
        expected = datetime.fromtimestamp(ts).strftime("%Y-%m-%dT%H:%M:%S.%fZ")


#------------------------------------------------
from together.utils.tools import convert_unix_timestamp

def test_convert_unix_timestamp():
    convert_unix_timestamp(0)
🔎 Concolic Coverage Tests and Runtime
Test File::Test Function Original ⏱️ Optimized ⏱️ Speedup
codeflash_concolic_atws5rsq/tmpu0h3d5ga/test_concolic_coverage.py::test_convert_unix_timestamp 10.9μs 6.07μs 79.7%✅

To edit these changes git checkout codeflash/optimize-convert_unix_timestamp-mgzqzpf1 and push.

Codeflash

@codeflash-ai
Optimize convert_unix_timestamp
b0d3fd5 
The optimization replaces the expensive `strftime()` method call with direct f-string formatting using datetime object attributes. Instead of `dt_object.strftime("%Y-%m-%dT%H:%M:%S.%fZ")`, the code now uses `f"{dt_object.year:04d}-{dt_object.month:02d}-{dt_object.day:02d}T{dt_object.hour:02d}:{dt_object.minute:02d}:{dt_object.second:02d}.{dt_object.microsecond:06d}Z"`.

This provides a **10% overall speedup** because:
- **Eliminates format string parsing**: `strftime()` must parse the format string `"%Y-%m-%dT%H:%M:%S.%fZ"` at runtime, while f-strings are compiled at parse time
- **Direct attribute access**: Accessing `dt_object.year`, `dt_object.month`, etc. is faster than the internal formatting logic in `strftime()`
- **Reduced function call overhead**: f-string formatting avoids the method call to `strftime()`

The line profiler shows the original `strftime()` line consumed 73.4% of execution time (10.3ms out of 14.0ms total), making it the clear bottleneck. The optimized version spreads this work across multiple f-string operations that are collectively faster.

**Test case performance**: The optimization shows consistent 30-60% speedup across individual test cases, with particularly strong gains (60-78%) on simple cases like epoch and basic timestamps. Even large-scale tests with 1000 iterations show 9-13% improvements, demonstrating the optimization scales well for batch processing scenarios.
@codeflash-ai
codeflash-ai Bot requested a review from mashraf-222 October 20, 2025 23:09
@codeflash-ai codeflash-ai Bot added the ⚡️ codeflash Optimization PR opened by Codeflash AI label Oct 20, 2025
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Reviewers

@mashraf-222 mashraf-222 Awaiting requested review from mashraf-222

Assignees

No one assigned

Labels

⚡️ codeflash Optimization PR opened by Codeflash AI

Projects

None yet

Milestone

No milestone

Development

Successfully merging this pull request may close these issues.

0 participants