⚡️ Speed up function _serial_download by 24% in PR #1354 (weights-download-speedup)

[codeflash-ai]

⚡️ This pull request contains optimizations for PR #1354

If you approve this dependent PR, these changes will be merged into the original PR branch weights-download-speedup.

This PR will be automatically closed if the original PR is merged.

---

📄 24% (0.24x) speedup for _serial_download in inference/core/roboflow_api.py

⏱️ Runtime : 924 microseconds → 747 microseconds (best of 44 runs)

📝 Explanation and details

Here is the optimized version of your code, rewritten for better runtime and memory performance.

• Optimization strategy:
  • Avoid unnecessary variable initializations and duplicate function calls.
  • Minimize expensive string formatting and JSON parsing.
  • Reduce time.time() calls inside tight loops.
  • Pre-calculate constants.
  • Reuse byte counters; only log when necessary.
  • In log calls, use conditional debug log early to avoid unnecessary string formatting.

All return values remain the same, and function signatures are not changed.
All comments are preserved or updated if code has changed.

Summary of changes:

• Avoid recomputing constants, unnecessary branching, duplicate string formatting when log level is not enabled.
• Only call time.time() and perform Mbps calculations when logging.
• Minor clean-ups for clarity.
• Final response construction is unchanged.
• Comments updated as needed, originals preserved.

This will be measurably faster and use slightly less memory, especially when downloading large files.

✅ Correctness verification report:

Test	Status
⏪ Replay Tests	🔘 None Found
⚙️ Existing Unit Tests	🔘 None Found
🔎 Concolic Coverage Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 12 Passed
📊 Tests Coverage	100.0%

🌀 Generated Regression Tests Details

import io
import json
import re
import time
# function to test and dependencies (as provided above)
import urllib
import urllib.parse
from typing import Dict, List, Optional, Union

# imports
import pytest
import requests
from inference.core.roboflow_api import _serial_download
from requests import Response


# --- Minimal logger stub for testing ---
class DummyLogger:
    def __init__(self):
        self.infos = []
        self.debugs = []
        self.warnings = []
    def info(self, msg):
        self.infos.append(msg)
    def debug(self, msg):
        self.debugs.append(msg)
    def warning(self, msg):
        self.warnings.append(msg)
logger = DummyLogger()

# --- Minimal env/config stubs for testing ---
ROBOFLOW_API_EXTRA_HEADERS = None
ROBOFLOW_API_REQUEST_TIMEOUT = 10
LICENSE_SERVER = None
from inference.core.roboflow_api import _serial_download

# --- Begin unit tests ---

# Monkeypatch utilities
class DummyResponse:
    def __init__(
        self, content_chunks, status_code=200, headers=None, encoding=None, reason=None, url="http://test/file"
    ):
        self._content_chunks = content_chunks
        self.status_code = status_code
        self.headers = headers or {}
        self.encoding = encoding
        self.reason = reason
        self.url = url
        self._iter_called = False
    def iter_content(self, chunk_size=8192):
        self._iter_called = True
        for chunk in self._content_chunks:
            yield chunk
    def raise_for_status(self):
        if self.status_code >= 400:
            raise requests.HTTPError(f"{self.status_code} Error", response=self)
    @property
    def content(self):
        return b"".join(self._content_chunks)

# Patch requests.get for all tests
@pytest.fixture(autouse=True)
def patch_requests_get(monkeypatch):
    # Patch requests.get to a dummy function for all tests
    monkeypatch.setattr(requests, "get", lambda *args, **kwargs: patch_requests_get.dummy_response)
    yield
    # Clean up after test
    patch_requests_get.dummy_response = None

# -------- BASIC TEST CASES --------

























import io
# Patch points for test isolation
import sys
import types

# imports
import pytest  # used for our unit tests
from inference.core.roboflow_api import _serial_download

# function to test and dependencies (already provided above)

# --- Test fixtures and helpers ---

class DummyLogger:
    """A logger that captures logs for inspection."""
    def __init__(self):
        self.infos = []
        self.debugs = []
        self.warnings = []
    def info(self, msg):
        self.infos.append(msg)
    def debug(self, msg):
        self.debugs.append(msg)
    def warning(self, msg):
        self.warnings.append(msg)

class DummyResponse:
    """A dummy Response object to simulate requests.Response."""
    def __init__(self, content=b"", status_code=200, headers=None, encoding=None, reason=None, url="http://test", chunk_size=8192):
        self._content = content
        self.status_code = status_code
        self.headers = headers or {}
        self.encoding = encoding
        self.reason = reason
        self.url = url
        self._chunk_size = chunk_size
        self._iter_content_called = False
        self._raise_for_status_called = False

    def iter_content(self, chunk_size=8192):
        """Yield content in chunks."""
        self._iter_content_called = True
        for i in range(0, len(self._content), chunk_size):
            yield self._content[i:i+chunk_size]

    def raise_for_status(self):
        self._raise_for_status_called = True
        if self.status_code >= 400:
            raise Exception(f"HTTP Error {self.status_code}")

# Patchable global config
class DummyEnv:
    def __init__(self):
        self.ROBOFLOW_API_EXTRA_HEADERS = None
        self.ROBOFLOW_API_REQUEST_TIMEOUT = 10
        self.LICENSE_SERVER = None

dummy_env = DummyEnv()

# Patch points for the test
@pytest.fixture(autouse=True)
def patch_dependencies(monkeypatch):
    # Patch logger
    logger = DummyLogger()
    monkeypatch.setattr("inference.core.logger", logger, raising=False)
    # Patch requests.get
    def dummy_requests_get(url, headers=None, timeout=None, stream=None):
        # Save call for inspection
        dummy_requests_get.last_call = dict(url=url, headers=headers, timeout=timeout, stream=stream)
        # Content will be set by test
        return dummy_requests_get.response
    monkeypatch.setattr("requests.get", dummy_requests_get)
    # Patch wrap_url to identity
    monkeypatch.setattr("inference.core.utils.url_utils.wrap_url", lambda url: url)
    # Patch build_roboflow_api_headers to None
    monkeypatch.setattr("inference.core.env.ROBOFLOW_API_EXTRA_HEADERS", dummy_env.ROBOFLOW_API_EXTRA_HEADERS, raising=False)
    monkeypatch.setattr("inference.core.env.ROBOFLOW_API_REQUEST_TIMEOUT", dummy_env.ROBOFLOW_API_REQUEST_TIMEOUT, raising=False)
    monkeypatch.setattr("inference.core.env.LICENSE_SERVER", dummy_env.LICENSE_SERVER, raising=False)
    # Patch api_key_safe_raise_for_status to just call raise_for_status
    def dummy_api_key_safe_raise_for_status(response):
        response.raise_for_status()
    monkeypatch.setattr("inference.core.utils.requests.api_key_safe_raise_for_status", dummy_api_key_safe_raise_for_status)
    # Patch time.time to a monotonic increasing fake clock for deterministic timing
    fake_time = [1000.0]
    def fake_time_time():
        fake_time[0] += 0.1
        return fake_time[0]
    monkeypatch.setattr("time.time", fake_time_time)
    # Patch wrap_url to identity
    monkeypatch.setattr("inference.core.utils.url_utils.wrap_url", lambda url: url)
    # Expose dummy logger and dummy_requests_get for test access
    yield logger, dummy_requests_get

# --- Basic Test Cases ---

def test_basic_small_file_download(patch_dependencies):
    """
    Test downloading a small file with known size.
    """
    logger, dummy_requests_get = patch_dependencies
    content = b"hello world"
    dummy_requests_get.response = DummyResponse(content=content, status_code=200)
    url = "http://example.com/file.txt"
    total_size = len(content)
    from inference.core.utils.requests import api_key_safe_raise_for_status
    from inference.core.utils.url_utils import wrap_url

    # Call
    codeflash_output = _serial_download(url, total_size); resp = codeflash_output # 41.3μs -> 41.4μs

def test_basic_unknown_size_download(patch_dependencies):
    """
    Test downloading a file with unknown size (total_size=0).
    """
    logger, dummy_requests_get = patch_dependencies
    content = b"abcdefg" * 10
    dummy_requests_get.response = DummyResponse(content=content, status_code=200)
    url = "http://example.com/unknown"
    total_size = 0
    codeflash_output = _serial_download(url, total_size); resp = codeflash_output # 21.4μs -> 26.2μs


def test_zero_byte_file(patch_dependencies):
    """
    Test downloading a file with zero bytes.
    """
    logger, dummy_requests_get = patch_dependencies
    content = b""
    dummy_requests_get.response = DummyResponse(content=content, status_code=200)
    url = "http://example.com/empty"
    codeflash_output = _serial_download(url, 0); resp = codeflash_output # 24.7μs -> 29.8μs

def test_one_byte_file(patch_dependencies):
    """
    Test downloading a file with one byte.
    """
    logger, dummy_requests_get = patch_dependencies
    content = b"a"
    dummy_requests_get.response = DummyResponse(content=content, status_code=200)
    url = "http://example.com/onebyte"
    codeflash_output = _serial_download(url, 1); resp = codeflash_output # 26.3μs -> 26.9μs

def test_non_200_status_raises(patch_dependencies):
    """
    Test that a non-200 status code raises an exception.
    """
    logger, dummy_requests_get = patch_dependencies
    content = b"fail"
    dummy_requests_get.response = DummyResponse(content=content, status_code=404)
    url = "http://example.com/missing"
    with pytest.raises(Exception):
        _serial_download(url, len(content))

def test_partial_chunk_download(patch_dependencies):
    """
    Test download where file size is not a multiple of chunk size.
    """
    logger, dummy_requests_get = patch_dependencies
    content = b"abc" * 3000 + b"z"  # 9001 bytes
    dummy_requests_get.response = DummyResponse(content=content, status_code=200)
    url = "http://example.com/weird"
    codeflash_output = _serial_download(url, len(content)); resp = codeflash_output # 30.1μs -> 27.9μs

def test_large_chunk_size_smaller_than_file(patch_dependencies, monkeypatch):
    """
    Test download with a chunk size larger than the file itself.
    """
    logger, dummy_requests_get = patch_dependencies
    content = b"abcdef"
    # Patch DummyResponse to use large chunk size
    dummy_requests_get.response = DummyResponse(content=content, status_code=200, chunk_size=1000)
    url = "http://example.com/largechunk"
    codeflash_output = _serial_download(url, len(content)); resp = codeflash_output # 24.5μs -> 24.2μs


def test_encoding_and_reason_and_url_propagation(patch_dependencies):
    """
    Test that encoding, reason, and url are propagated to the returned Response.
    """
    logger, dummy_requests_get = patch_dependencies
    content = b"abc"
    dummy_requests_get.response = DummyResponse(
        content=content,
        status_code=200,
        encoding="utf-8",
        reason="OK",
        url="http://example.com/somefile"
    )
    url = "http://example.com/somefile"
    codeflash_output = _serial_download(url, len(content)); resp = codeflash_output # 31.2μs -> 31.9μs

# --- Large Scale Test Cases ---

def test_large_file_download(patch_dependencies):
    """
    Test downloading a large file (close to 1MB).
    """
    logger, dummy_requests_get = patch_dependencies
    size = 900 * 1024  # 900KB
    content = b"x" * size
    dummy_requests_get.response = DummyResponse(content=content, status_code=200)
    url = "http://example.com/largefile"
    codeflash_output = _serial_download(url, size); resp = codeflash_output # 308μs -> 197μs

def test_many_chunks_download(patch_dependencies):
    """
    Test downloading a file that will be split into many chunks (e.g., 819 bytes * 100 = 81,900 bytes).
    """
    logger, dummy_requests_get = patch_dependencies
    chunk = b"abcdefghij" * 81  # 810 bytes
    content = chunk * 100  # 81,000 bytes
    dummy_requests_get.response = DummyResponse(content=content, status_code=200)
    url = "http://example.com/manychunks"
    codeflash_output = _serial_download(url, len(content)); resp = codeflash_output # 51.9μs -> 40.5μs


def test_download_speed_logging(patch_dependencies):
    """
    Test that download speed is logged and progress logs are made for large files.
    """
    logger, dummy_requests_get = patch_dependencies
    size = 512 * 1024  # 512KB
    content = b"z" * size
    dummy_requests_get.response = DummyResponse(content=content, status_code=200)
    url = "http://example.com/speed"
    codeflash_output = _serial_download(url, size); resp = codeflash_output # 179μs -> 110μs
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

To edit these changes git checkout codeflash/optimize-pr1354-2025-06-18T22.17.50 and push.

[misrasaurabh1]

Suggested change

# Avoid unnecessary type annotation here, and don't parse twice

[misrasaurabh1]

Suggested change

	extra_headers = json.loads(ROBOFLOW_API_EXTRA_HEADERS)
	extra_headers: dict = json.loads(ROBOFLOW_API_EXTRA_HEADERS)

[grzegorz-roboflow]

It would be great if generated code was focusing only on those lines contributing on performance improvements

[misrasaurabh1]

yes, we are currently working on a project that refines the generated code to revert any lines that don't lead to any performance impact.

[misrasaurabh1]

i reviewed this and this mostly looks good for me. speed up the iteration by removing logic out of the inner loop, plus if debug is disabled then avoid a lot of unnecessary compute.

[grzegorz-roboflow]

Suggested change

# Construct final response object efficiently