GPT 5.4 review

Author: PastelStorm

.github/workflows/ci.yaml

@@ -32,6 +32,7 @@ jobs:
         python-version: ${{ matrix.python-version }}
     - name: Install dependencies
       env:
+        UV_LOCKED: "1"
         UV_PYTHON: ${{ matrix.python-version }}
       run: make install
     - name: Run unit tests
@@ -51,6 +52,7 @@ jobs:
         python-version: "3.13"
     - name: Install dependencies
       env:
+        UV_LOCKED: "1"
         UV_PYTHON: "3.13"
       run: make install
     - name: Lint
@@ -74,6 +76,7 @@ jobs:
         python-version: ${{ matrix.python-version }}
     - name: Install dependencies
       env:
+        UV_LOCKED: "1"
         UV_PYTHON: ${{ matrix.python-version }}
       run: make install
     - name: Run integration tests
@@ -98,6 +101,7 @@ jobs:
           python-version: ${{ matrix.python-version }}
       - name: Install dependencies
         env:
+          UV_LOCKED: "1"
           UV_PYTHON: ${{ matrix.python-version }}
         run: |
           make install

Makefile

@@ -11,7 +11,7 @@ DOCKER_IMAGE ?= downloads.unstructured.io/unstructured-io/unstructured-api:lates
 .PHONY: install
 install:
 	python scripts/prepare_readme.py
-	uv sync
+	uv sync --locked
 
 ## install-speakeasy-cli:			download the speakeasy cli tool
 .PHONY: install-speakeasy-cli

_test_unstructured_client/integration/test_decorators.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+from collections import Counter, defaultdict
+import math
 import tempfile
 from pathlib import Path
 from typing import Literal
@@ -26,25 +28,77 @@
 _HI_RES_STRATEGIES = ("hi_res", Strategy.HI_RES)
 
 
+def _allowed_delta(expected: int, *, absolute: int, ratio: float) -> int:
+    return max(absolute, math.ceil(expected * ratio))
+
+
+def _text_size(elements) -> int:
+    return sum(len((element.get("text") or "").strip()) for element in elements)
+
+
+def _elements_by_page(elements):
+    pages = defaultdict(list)
+    for element in elements:
+        pages[element["metadata"]["page_number"]].append(element)
+    return pages
+
+
+def _assert_hi_res_output_is_similar(resp_split, resp_single):
+    split_pages = _elements_by_page(resp_split.elements)
+    single_pages = _elements_by_page(resp_single.elements)
+
+    assert set(split_pages) == set(single_pages)
+
+    assert abs(len(resp_split.elements) - len(resp_single.elements)) <= _allowed_delta(
+        len(resp_single.elements),
+        absolute=4,
+        ratio=0.1,
+    )
+
+    split_type_counts = Counter(element["type"] for element in resp_split.elements)
+    single_type_counts = Counter(element["type"] for element in resp_single.elements)
+    assert set(split_type_counts) == set(single_type_counts)
+    for element_type, expected_count in single_type_counts.items():
+        assert abs(split_type_counts[element_type] - expected_count) <= _allowed_delta(
+            expected_count,
+            absolute=2,
+            ratio=0.2,
+        )
+
+    assert abs(_text_size(resp_split.elements) - _text_size(resp_single.elements)) <= _allowed_delta(
+        _text_size(resp_single.elements),
+        absolute=250,
+        ratio=0.2,
+    )
+
+    for page_number, single_page_elements in single_pages.items():
+        split_page_elements = split_pages[page_number]
+
+        assert abs(len(split_page_elements) - len(single_page_elements)) <= _allowed_delta(
+            len(single_page_elements),
+            absolute=2,
+            ratio=0.2,
+        )
+        assert abs(_text_size(split_page_elements) - _text_size(single_page_elements)) <= _allowed_delta(
+            _text_size(single_page_elements),
+            absolute=120,
+            ratio=0.3,
+        )
+
+
 def _assert_split_unsplit_equivalent(resp_split, resp_single, strategy, extra_exclude_paths=None):
     """Compare split-PDF and single-request responses.
 
     For hi_res (OCR-based), splitting changes per-page context so text and
-    element counts can vary slightly.  We only check structural equivalence.
+    OCR text can vary slightly. We still check page coverage, type distribution,
+    and text volume so split requests cannot silently drift too far.
     For deterministic strategies (fast, etc.) we keep strict DeepDiff equality.
     """
     assert resp_split.status_code == resp_single.status_code
     assert resp_split.content_type == resp_single.content_type
 
     if strategy in _HI_RES_STRATEGIES:
-        count_diff = abs(len(resp_split.elements) - len(resp_single.elements))
-        assert count_diff <= 10, (
-            f"Element count diverged too far: "
-            f"{len(resp_split.elements)} vs {len(resp_single.elements)}"
-        )
-        split_pages = {e["metadata"]["page_number"] for e in resp_split.elements}
-        single_pages = {e["metadata"]["page_number"] for e in resp_single.elements}
-        assert split_pages == single_pages
+        _assert_hi_res_output_is_similar(resp_split, resp_single)
     else:
         assert len(resp_split.elements) == len(resp_single.elements)
 

_test_unstructured_client/integration/test_integration.py

@@ -5,6 +5,7 @@
 import os
 from pathlib import Path
 
+from deepdiff import DeepDiff
 import pytest
 from unstructured_client import UnstructuredClient
 from unstructured_client.models import shared, operations
@@ -134,7 +135,8 @@ async def test_partition_async_returns_elements(client, doc_path):
 async def test_partition_async_processes_concurrent_files(client, doc_path):
     """
     Assert that partition_async can be used to send multiple files concurrently.
-    Sends two page ranges via asyncio.gather and verifies both return valid results.
+    Send two page ranges serially and then via asyncio.gather.
+    Both execution modes should return the same payloads.
     """
     filename = "layout-parser-paper.pdf"
 
@@ -165,14 +167,28 @@ async def test_partition_async_processes_concurrent_files(client, doc_path):
         )
     ]
 
+    serial_results = []
+    for req in requests:
+        res = await client.general.partition_async(request=req)
+        assert res.status_code == 200
+        serial_results.append(res.elements)
+
     results = await asyncio.gather(
         client.general.partition_async(request=requests[0]),
         client.general.partition_async(request=requests[1])
     )
 
+    concurrent_results = []
     for res in results:
         assert res.status_code == 200
-        assert len(res.elements) > 0
+        concurrent_results.append(res.elements)
+
+    diff = DeepDiff(
+        t1=serial_results,
+        t2=concurrent_results,
+        ignore_order=True,
+    )
+    assert len(diff) == 0
 
 
 def test_uvloop_partitions_without_errors(client, doc_path):

_test_unstructured_client/unit/test_regeneration_guards.py

@@ -40,6 +40,19 @@ def test_publish_script_is_hardened():
     assert 'uv publish --token "${PYPI_TOKEN}" --check-url https://pypi.org/simple' in publish_script
 
 
+def test_makefile_installs_with_locked_uv_sync():
+    makefile = (REPO_ROOT / "Makefile").read_text()
+
+    assert "uv sync --locked" in makefile
+
+
+def test_ci_installs_with_locked_uv_sync():
+    workflow = (REPO_ROOT / ".github" / "workflows" / "ci.yaml").read_text()
+
+    assert 'UV_LOCKED: "1"' in workflow
+    assert "run: make install" in workflow
+
+
 def test_body_create_job_input_files_are_serialized_as_multipart_files():
     request = shared.BodyCreateJob(
         request_data="{}",