vellum-ai 0.14.41__py3-none-any.whl → 1.11.2__py3-none-any.whl

vellum/utils/files/stream.py

@@ -0,0 +1,135 @@
+"""Streaming utilities for reading Vellum files."""
+
+import base64
+from contextlib import contextmanager
+from io import BytesIO
+import re
+from typing import TYPE_CHECKING, Generator, Iterator, Optional
+
+import requests
+
+from vellum.client.core.api_error import ApiError
+from vellum.utils.files.constants import BASE64_DATA_URL_PATTERN, URL_PATTERN, VELLUM_FILE_SRC_PATTERN
+from vellum.utils.files.exceptions import FileNotFoundError, FileRetrievalError, InvalidFileSourceError
+from vellum.utils.files.types import VellumFileTypes
+
+if TYPE_CHECKING:
+    from vellum.client import Vellum as VellumClient
+
+
+@contextmanager
+def stream_vellum_file(
+    vellum_file: VellumFileTypes,
+    *,
+    chunk_size: int = 8192,
+    vellum_client: Optional["VellumClient"] = None,
+) -> Generator[Iterator[bytes], None, None]:
+    """
+    Stream the file content in chunks using a context manager.
+
+    This is the recommended way to read large files, as it avoids loading
+    the entire file into memory at once.
+
+    Args:
+        vellum_file: A VellumDocument, VellumImage, VellumAudio, or VellumVideo instance
+        chunk_size: Size of chunks to yield in bytes (default 8KB)
+        vellum_client: An optional Vellum client instance. If not provided, a default client will be created.
+
+    Yields:
+        Iterator[bytes]: Chunks of file content
+
+    Example:
+        ```python
+        from vellum import VellumVideo
+        from vellum.utils.files import stream_vellum_file
+
+        # Stream a large video file
+        video = VellumVideo(src="https://example.com/video.mp4")
+        with stream_vellum_file(video, chunk_size=10*1024*1024) as chunks:  # 10MB chunks
+            with open('output.mp4', 'wb') as f:
+                for chunk in chunks:
+                    f.write(chunk)
+
+        # Calculate hash without loading entire file
+        import hashlib
+        hasher = hashlib.sha256()
+        with stream_vellum_file(vellum_file) as chunks:
+            for chunk in chunks:
+                hasher.update(chunk)
+        hash_value = hasher.hexdigest()
+        ```
+    """
+    src = vellum_file.src
+
+    # Case 1: Base64 Data URL
+    # Note: Base64 content is already in memory, but we still provide
+    # a streaming interface for consistency
+    data_url_match = re.match(BASE64_DATA_URL_PATTERN, src)
+    if data_url_match:
+        base64_content = data_url_match.group(3)
+        decoded = base64.b64decode(base64_content)
+        stream = BytesIO(decoded)
+        try:
+            yield _chunk_iterator(stream, chunk_size)
+        finally:
+            stream.close()
+        return
+
+    file_url: str
+
+    # Case 2: Vellum Uploaded File
+    match = re.match(VELLUM_FILE_SRC_PATTERN, src, re.IGNORECASE)
+    if match:
+        vellum_uploaded_file_id = match.group(1)
+        if vellum_client is None:
+            from vellum.utils.vellum_client import create_vellum_client
+
+            vellum_client = create_vellum_client()
+
+        try:
+            uploaded_file = vellum_client.uploaded_files.retrieve(vellum_uploaded_file_id)
+        except ApiError as e:
+            if e.status_code == 404:
+                raise FileNotFoundError(f"Uploaded file not found: {vellum_uploaded_file_id}") from e
+            raise FileRetrievalError(f"Failed to retrieve uploaded file: {vellum_uploaded_file_id}") from e
+
+        if not uploaded_file.file_url:
+            raise FileRetrievalError(f"Uploaded file has no accessible URL: {vellum_uploaded_file_id}")
+
+        file_url = uploaded_file.file_url
+
+    # Case 3: Direct URL
+    elif re.match(URL_PATTERN, src):
+        file_url = src
+    else:
+        raise InvalidFileSourceError(
+            f"Invalid file source: {src}. "
+            "Expected a base64 data URL (data:...;base64,...), "
+            "a Vellum uploaded file ID (vellum:uploaded-file:...), "
+            "or an HTTP/HTTPS URL."
+        )
+
+    # Stream from URL
+    try:
+        response = requests.get(file_url, stream=True)
+        response.raise_for_status()
+    except requests.HTTPError as e:
+        if e.response.status_code == 404:
+            raise FileNotFoundError(f"File not found at URL: {file_url}") from e
+        raise FileRetrievalError(f"Failed to retrieve file from URL: {file_url}") from e
+    except requests.RequestException as e:
+        raise FileRetrievalError(f"Network error while retrieving file: {file_url}") from e
+
+    try:
+        yield response.iter_content(chunk_size=chunk_size)
+    finally:
+        response.close()
+
+
+def _chunk_iterator(stream: BytesIO, chunk_size: int) -> Iterator[bytes]:
+    """Helper to read a BytesIO stream in chunks."""
+    while True:
+        chunk = stream.read(chunk_size)
+        if not chunk:
+            break
+        yield chunk

vellum/utils/files/tests/test_extensions.py

@@ -0,0 +1,54 @@
+"""Tests for file extension inference utilities."""
+
+import pytest
+
+from vellum.utils.files.extensions import ensure_filename_with_extension
+
+
+@pytest.mark.parametrize(
+    ["filename", "mime_type", "expected"],
+    [
+        # None filename cases - should default to 'file' with inferred extension
+        pytest.param(None, "application/pdf", "file.pdf", id="none_filename_pdf"),
+        pytest.param(None, "image/png", "file.png", id="none_filename_png"),
+        pytest.param(None, "image/jpeg", "file.jpg", id="none_filename_jpeg_normalized"),
+        pytest.param(None, "text/plain", "file.txt", id="none_filename_txt"),
+        pytest.param(None, "video/mp4", "file.mp4", id="none_filename_mp4"),
+        pytest.param(None, "audio/mpeg", "file.mp3", id="none_filename_mp3"),
+        pytest.param(None, "text/markdown", "file.md", id="none_filename_markdown"),
+        pytest.param(None, "application/x-yaml", "file.yaml", id="none_filename_yaml_x"),
+        pytest.param(None, "text/yaml", "file.yaml", id="none_filename_yaml_text"),
+        pytest.param(None, "application/gzip", "file.gz", id="none_filename_gzip"),
+        pytest.param(None, "application/xml", "file.xml", id="none_filename_xml_normalized"),
+        pytest.param(None, "application/octet-stream", "file.bin", id="none_filename_octet_stream"),
+        pytest.param(None, "application/x-unknown-type", "file.bin", id="none_filename_unknown_mime"),
+        # Filename without extension - should add appropriate extension
+        pytest.param("document", "application/pdf", "document.pdf", id="document_without_ext_pdf"),
+        pytest.param("report", "application/pdf", "report.pdf", id="report_without_ext_pdf"),
+        pytest.param(
+            "report",
+            "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+            "report.docx",
+            id="report_without_ext_docx",
+        ),
+        pytest.param("config", "application/x-yaml", "config.yaml", id="config_without_ext_yaml_x"),
+        pytest.param("config", "text/yaml", "config.yaml", id="config_without_ext_yaml_text"),
+        pytest.param("README", "text/markdown", "README.md", id="readme_without_ext_markdown"),
+        pytest.param("data", "text/csv", "data.csv", id="data_without_ext_csv"),
+        pytest.param("data", "application/octet-stream", "data.bin", id="data_without_ext_bin"),
+        pytest.param("archive", "application/gzip", "archive.gz", id="archive_without_ext_gzip"),
+        pytest.param("file", "application/pdf", "file.pdf", id="file_without_ext_pdf"),
+        # Filename with extension - should keep existing extension
+        pytest.param("document.pdf", "application/pdf", "document.pdf", id="document_pdf_with_ext"),
+        pytest.param("image.png", "image/jpeg", "image.png", id="image_png_mismatched_mime"),
+        pytest.param("data.csv", "text/csv", "data.csv", id="data_csv_with_ext"),
+        pytest.param("config.yaml", "application/x-yaml", "config.yaml", id="config_yaml_with_ext"),
+        # MIME type with parameters - should strip parameters
+        pytest.param(None, "text/html; charset=utf-8", "file.html", id="none_filename_html_with_charset"),
+        pytest.param("page", "text/html; charset=utf-8", "page.html", id="page_without_ext_html_with_charset"),
+    ],
+)
+def test_ensure_filename_with_extension(filename, mime_type, expected):
+    """Test filename extension inference for various filename and MIME type combinations."""
+    result = ensure_filename_with_extension(filename, mime_type)
+    assert result == expected

vellum/utils/files/tests/test_mixin.py

@@ -0,0 +1,205 @@
+import base64
+from unittest.mock import Mock, patch
+
+from vellum.utils.files import VellumFileMixin
+
+# Sample content for testing
+SAMPLE_TEXT_CONTENT = b"Hello, this is a test document!"
+
+
+class TestDocument(VellumFileMixin):
+    """Test class that demonstrates how VellumFileMixin is used in postprocess.
+
+    This mirrors the pattern used in postprocess.ts where file types inherit from
+    VellumFileMixin (which extends UniversalBaseModel), replacing UniversalBaseModel.
+    """
+
+    src: str
+
+
+def test_vellum_file_mixin_stream_method():
+    """Test that VellumFileMixin.stream() method works."""
+
+    # GIVEN a test document with base64 content using the mixin (like postprocess does)
+    content = b"Hello, this is a test document!"
+    base64_content = base64.b64encode(content).decode("utf-8")
+    src = f"data:text/plain;base64,{base64_content}"
+    test_file = TestDocument(src=src)
+
+    # WHEN streaming using the mixin's .stream() method
+    chunks = []
+    with test_file.stream() as chunk_iter:
+        for chunk in chunk_iter:
+            chunks.append(chunk)
+
+    # THEN the content should match
+    result = b"".join(chunks)
+    assert result == content
+
+
+def test_vellum_file_mixin_stream_method_with_custom_chunk_size():
+    """Test that VellumFileMixin.stream() respects custom chunk_size parameter."""
+
+    # GIVEN a test document with content using the mixin (like postprocess does)
+    content = b"This is a longer document that will be split into multiple chunks."
+    base64_content = base64.b64encode(content).decode("utf-8")
+    src = f"data:text/plain;base64,{base64_content}"
+    test_file = TestDocument(src=src)
+
+    # WHEN streaming with a small chunk size using the mixin
+    chunk_size = 10
+    chunks = []
+    with test_file.stream(chunk_size=chunk_size) as chunk_iter:
+        for chunk in chunk_iter:
+            chunks.append(chunk)
+            # Each chunk should be <= chunk_size (last chunk may be smaller)
+            assert len(chunk) <= chunk_size
+
+    # THEN the content should match when reassembled
+    result = b"".join(chunks)
+    assert result == content
+    # AND we should have multiple chunks for content larger than chunk_size
+    assert len(chunks) > 1
+
+
+def test_vellum_file_mixin_stream_method_from_url():
+    """Test that VellumFileMixin.stream() method works for files from URLs."""
+
+    # GIVEN a test document with a URL source using the mixin (like postprocess does)
+    content = b"URL fetched content that will be streamed"
+    url = "https://example.com/file.dat"
+    test_file = TestDocument(src=url)
+
+    # WHEN streaming using the mixin's .stream() method
+    with patch("vellum.utils.files.stream.requests.get") as mock_get:
+        mock_response = Mock()
+        # Simulate streaming response with iter_content
+        mock_response.iter_content = Mock(return_value=iter([content[:20], content[20:]]))
+        mock_response.raise_for_status = Mock()
+        mock_response.close = Mock()
+        mock_get.return_value = mock_response
+
+        chunks = []
+        with test_file.stream() as chunk_iter:
+            for chunk in chunk_iter:
+                chunks.append(chunk)
+
+        result = b"".join(chunks)
+        assert result == content
+        mock_get.assert_called_once_with(url, stream=True)
+        mock_response.raise_for_status.assert_called_once()
+        mock_response.close.assert_called_once()
+
+
+def test_vellum_file_mixin_read_method():
+    """Test that VellumFileMixin.read() method works."""
+
+    # GIVEN a test document with base64 content using the mixin (like postprocess does)
+    content = b"Hello, this is a test document!"
+    base64_content = base64.b64encode(content).decode("utf-8")
+    src = f"data:text/plain;base64,{base64_content}"
+    test_file = TestDocument(src=src)
+
+    # WHEN reading using the mixin's .read() method
+    result = test_file.read()
+
+    # THEN the content should match
+    assert result == content
+
+
+def test_vellum_file_mixin_upload_method():
+    """Test that VellumFileMixin.upload() method works."""
+
+    # GIVEN a test document with base64 content using the mixin (like postprocess does)
+    content = b"Hello, this is a test document!"
+    base64_content = base64.b64encode(content).decode("utf-8")
+    src = f"data:text/plain;base64,{base64_content}"
+    test_file = TestDocument(src=src)
+    uploaded_file_id = "12345678-1234-1234-1234-123456789abc"
+
+    # WHEN uploading using the mixin's .upload() method
+    with patch("vellum.utils.vellum_client.create_vellum_client") as mock_create_client:
+        mock_client = Mock()
+        mock_client.uploaded_files.create.return_value = Mock(id=uploaded_file_id)
+        mock_create_client.return_value = mock_client
+
+        result = test_file.upload()
+
+        # THEN the file should be uploaded and return a new instance with uploaded source
+        assert result.src == f"vellum:uploaded-file:{uploaded_file_id}"
+        assert isinstance(result, TestDocument)
+        mock_client.uploaded_files.create.assert_called_once()
+
+
+def test_vellum_file_mixin_get_signed_url_method():
+    """Test that VellumFileMixin.get_signed_url() method works."""
+
+    # GIVEN a test document with base64 content using the mixin (like postprocess does)
+    content = b"Hello, this is a test document!"
+    base64_content = base64.b64encode(content).decode("utf-8")
+    src = f"data:text/plain;base64,{base64_content}"
+    test_file = TestDocument(src=src)
+    uploaded_file_id = "12345678-1234-1234-1234-123456789abc"
+    signed_url = "https://storage.vellum.ai/files/signed?token=abc123"
+
+    # WHEN getting the signed URL using the mixin's .get_signed_url() method
+    with patch("vellum.utils.vellum_client.create_vellum_client") as mock_create_client:
+        mock_client = Mock()
+        mock_client.uploaded_files.create.return_value = Mock(id=uploaded_file_id)
+        mock_client.uploaded_files.retrieve.return_value = Mock(file_url=signed_url)
+        mock_create_client.return_value = mock_client
+
+        result = test_file.get_signed_url()
+
+        # THEN the file should be uploaded and signed URL returned
+        assert result == signed_url
+        mock_client.uploaded_files.create.assert_called_once()
+        mock_client.uploaded_files.retrieve.assert_called_once_with(uploaded_file_id, expiry_seconds=604800)
+
+
+def test_vellum_file_mixin_get_signed_url_method_with_custom_client():
+    """Test that VellumFileMixin.get_signed_url() respects custom vellum_client parameter."""
+
+    # GIVEN a test document with base64 content using the mixin (like postprocess does)
+    content = b"Hello, this is a test document!"
+    base64_content = base64.b64encode(content).decode("utf-8")
+    src = f"data:text/plain;base64,{base64_content}"
+    test_file = TestDocument(src=src)
+    uploaded_file_id = "aaaa1111-bbbb-2222-cccc-3333dddd4444"
+    signed_url = "https://custom.storage.com/signed"
+
+    # Create custom client
+    custom_client = Mock()
+    custom_client.uploaded_files.create.return_value = Mock(id=uploaded_file_id)
+    custom_client.uploaded_files.retrieve.return_value = Mock(file_url=signed_url)
+
+    # WHEN getting the signed URL using the mixin with a custom client
+    result = test_file.get_signed_url(vellum_client=custom_client)
+
+    # THEN the custom client should be used
+    assert result == signed_url
+    custom_client.uploaded_files.create.assert_called_once()
+    custom_client.uploaded_files.retrieve.assert_called_once_with(uploaded_file_id, expiry_seconds=604800)
+
+
+def test_vellum_file_mixin_get_signed_url_method_already_uploaded():
+    """Test that VellumFileMixin.get_signed_url() works for already uploaded files."""
+
+    # GIVEN a test document that's already uploaded using the mixin
+    file_id = "12345678-1234-1234-1234-123456789abc"
+    src = f"vellum:uploaded-file:{file_id}"
+    test_file = TestDocument(src=src)
+    signed_url = "https://storage.vellum.ai/files/signed"
+
+    # WHEN getting the signed URL using the mixin's .get_signed_url() method
+    with patch("vellum.utils.vellum_client.create_vellum_client") as mock_create_client:
+        mock_client = Mock()
+        mock_client.uploaded_files.retrieve.return_value = Mock(file_url=signed_url)
+        mock_create_client.return_value = mock_client
+
+        result = test_file.get_signed_url()
+
+        # THEN the signed URL should be returned without uploading again
+        assert result == signed_url
+        mock_client.uploaded_files.create.assert_not_called()
+        mock_client.uploaded_files.retrieve.assert_called_once_with(file_id, expiry_seconds=604800)

vellum/utils/files/tests/test_read.py

@@ -0,0 +1,204 @@
+import pytest
+import base64
+from unittest.mock import Mock, patch
+
+from vellum import VellumAudio, VellumDocument, VellumImage, VellumVideo
+from vellum.utils.files import FileRetrievalError, InvalidFileSourceError, read_vellum_file
+
+# Sample content for different file types
+SAMPLE_TEXT_CONTENT = b"This is a sample text document content."
+SAMPLE_IMAGE_CONTENT = b"\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x01"  # Minimal PNG header
+SAMPLE_AUDIO_CONTENT = b"RIFF\x00\x00\x00\x00WAVEfmt "  # Minimal WAV header
+SAMPLE_VIDEO_CONTENT = b"\x00\x00\x00\x20ftypmp42"  # Minimal MP4 header
+
+
+@pytest.mark.parametrize(
+    ["file_type", "content", "mime_type"],
+    [
+        (VellumDocument, SAMPLE_TEXT_CONTENT, "text/plain"),
+        (VellumImage, SAMPLE_IMAGE_CONTENT, "image/png"),
+        (VellumAudio, SAMPLE_AUDIO_CONTENT, "audio/wav"),
+        (VellumVideo, SAMPLE_VIDEO_CONTENT, "video/mp4"),
+    ],
+)
+def test_read_vellum_file_base64_data_url_with_mime_type(file_type, content, mime_type):
+    """Test reading files from base64 data URLs with MIME types."""
+    # Encode content as base64
+    base64_content = base64.b64encode(content).decode("utf-8")
+    src = f"data:{mime_type};base64,{base64_content}"
+
+    # Create the appropriate file type
+    vellum_file = file_type(src=src)
+
+    # Read the file
+    result = read_vellum_file(vellum_file)
+
+    # Verify the content matches
+    assert result == content
+
+
+@pytest.mark.parametrize(
+    ["file_type", "content"],
+    [
+        (VellumDocument, SAMPLE_TEXT_CONTENT),
+        (VellumImage, SAMPLE_IMAGE_CONTENT),
+        (VellumAudio, SAMPLE_AUDIO_CONTENT),
+        (VellumVideo, SAMPLE_VIDEO_CONTENT),
+    ],
+)
+def test_read_vellum_file_base64_data_url_without_mime_type(file_type, content):
+    """Test reading files from base64 data URLs without MIME types."""
+    # Encode content as base64
+    base64_content = base64.b64encode(content).decode("utf-8")
+    src = f"data:;base64,{base64_content}"
+
+    # Create the appropriate file type
+    vellum_file = file_type(src=src)
+
+    # Read the file
+    result = read_vellum_file(vellum_file)
+
+    # Verify the content matches
+    assert result == content
+
+
+@pytest.mark.parametrize(
+    ["file_type", "content", "mime_type", "charset"],
+    [
+        (VellumDocument, SAMPLE_TEXT_CONTENT, "text/plain", "utf-8"),
+        (VellumDocument, SAMPLE_TEXT_CONTENT, "text/html", "iso-8859-1"),
+        (VellumImage, SAMPLE_IMAGE_CONTENT, "image/png", "utf-8"),
+    ],
+)
+def test_read_vellum_file_base64_data_url_with_charset(file_type, content, mime_type, charset):
+    """Test reading files from base64 data URLs with charset specifications."""
+    # Encode content as base64
+    base64_content = base64.b64encode(content).decode("utf-8")
+    src = f"data:{mime_type};charset={charset};base64,{base64_content}"
+
+    # Create the appropriate file type
+    vellum_file = file_type(src=src)
+
+    # Read the file
+    result = read_vellum_file(vellum_file)
+
+    # Verify the content matches
+    assert result == content
+
+
+@pytest.mark.parametrize(
+    ["file_type", "content"],
+    [
+        (VellumDocument, b""),  # Empty file
+        (VellumImage, b"x" * 1000),  # Larger content
+        (VellumAudio, b"\x00\x01\x02\x03\x04"),  # Binary content with special bytes
+        (VellumVideo, b"Unicode content: \xc3\xa9\xc3\xa0\xc3\xb1"),  # UTF-8 encoded content
+    ],
+)
+def test_read_vellum_file_base64_edge_cases(file_type, content):
+    """Test reading files with edge case content (empty, large, special characters)."""
+    # Encode content as base64
+    base64_content = base64.b64encode(content).decode("utf-8")
+    src = f"data:application/octet-stream;base64,{base64_content}"
+
+    # Create the appropriate file type
+    vellum_file = file_type(src=src)
+
+    # Read the file
+    result = read_vellum_file(vellum_file)
+
+    # Verify the content matches
+    assert result == content
+
+
+@pytest.mark.parametrize(
+    "file_type",
+    [VellumDocument, VellumImage, VellumAudio, VellumVideo],
+)
+def test_read_vellum_file_from_url(file_type):
+    """Test reading files from direct URLs."""
+    content = b"URL fetched content"
+    url = "https://example.com/file.dat"
+
+    vellum_file = file_type(src=url)
+
+    with patch("vellum.utils.files.stream.requests.get") as mock_get:
+        mock_response = Mock()
+        # Mock streaming interface
+        mock_response.iter_content = Mock(return_value=iter([content]))
+        mock_response.raise_for_status = Mock()
+        mock_response.close = Mock()
+        mock_get.return_value = mock_response
+
+        result = read_vellum_file(vellum_file)
+
+        assert result == content
+        mock_get.assert_called_once_with(url, stream=True)
+        mock_response.raise_for_status.assert_called_once()
+        mock_response.close.assert_called_once()
+
+
+@pytest.mark.parametrize(
+    "file_type",
+    [VellumDocument, VellumImage, VellumAudio, VellumVideo],
+)
+def test_read_vellum_file_from_vellum_uploaded_file(file_type):
+    """Test reading files from Vellum uploaded file IDs."""
+    content = b"Vellum uploaded content"
+    file_id = "12345678-1234-1234-1234-123456789abc"
+    src = f"vellum:uploaded-file:{file_id}"
+    file_url = "https://s3.amazonaws.com/example/file.dat"
+
+    vellum_file = file_type(src=src)
+
+    with patch("vellum.utils.vellum_client.create_vellum_client") as mock_create_client, patch(
+        "vellum.utils.files.stream.requests.get"
+    ) as mock_get:
+        # Mock the Vellum client
+        mock_client = Mock()
+        uploaded_file_mock = Mock()
+        uploaded_file_mock.file_url = file_url
+        mock_client.uploaded_files.retrieve.return_value = uploaded_file_mock
+        mock_create_client.return_value = mock_client
+
+        # Mock the file download with streaming interface
+        file_response = Mock()
+        file_response.iter_content = Mock(return_value=iter([content]))
+        file_response.raise_for_status = Mock()
+        file_response.close = Mock()
+
+        mock_get.return_value = file_response
+
+        result = read_vellum_file(vellum_file)
+
+        assert result == content
+        mock_client.uploaded_files.retrieve.assert_called_once_with(file_id)
+        mock_get.assert_called_once_with(file_url, stream=True)
+        file_response.close.assert_called_once()
+
+
+def test_read_vellum_file_invalid_src():
+    """Test that invalid src raises InvalidFileSourceError."""
+    vellum_file = VellumDocument(src="invalid://source")
+
+    with pytest.raises(InvalidFileSourceError, match="Invalid file source"):
+        read_vellum_file(vellum_file)
+
+
+def test_read_vellum_file_vellum_uploaded_file_missing_url():
+    """Test that missing file_url in API response raises FileRetrievalError."""
+    file_id = "12345678-1234-1234-1234-123456789abc"
+    src = f"vellum:uploaded-file:{file_id}"
+
+    vellum_file = VellumDocument(src=src)
+
+    # Mock the create_vellum_client to return a client with an uploaded file without a file_url
+    with patch("vellum.utils.vellum_client.create_vellum_client") as mock_create_client:
+        mock_client = Mock()
+        uploaded_file_mock = Mock()
+        uploaded_file_mock.file_url = None
+        mock_client.uploaded_files.retrieve.return_value = uploaded_file_mock
+        mock_create_client.return_value = mock_client
+
+        with pytest.raises(FileRetrievalError, match="has no accessible URL"):
+            read_vellum_file(vellum_file)