visionai-sdk-python 2.0.0__tar.gz → 2.1.0__tar.gz

{visionai_sdk_python-2.0.0 → visionai_sdk_python-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: visionai-sdk-python
-Version: 2.0.0
+Version: 2.1.0
 Summary: VisionAI SDK for Python
 Author-email: Tony Yang <tonyyang@linkervision.com>
 Requires-Python: >=3.11
@@ -27,6 +27,7 @@ Python client library for VisionAI authentication and Vision Language Model (VLM
 - **Auto Token Management**: Automatic token refresh before expiration
 - **JWT Validation**: Built-in token signature and expiration verification
 - **VLM Inference**: Submit and poll vision-language model tasks
+- **Resize Planning**: Compute VLM input dimensions (smart / square resize) without any image dependency — the caller does the actual resize
 - **Async Support**: Full async/await support with `AsyncClient`
 - **Type Safe**: Full type hints with Pydantic validation
 - **Service Source Attribution**: Auto-attach a service-source header to every outbound `requests`/`httpx`/`aiohttp` call with a single startup call
@@ -187,6 +188,43 @@ elif result.status in ("failed", "timeout"):
 - `failed`: Error, check `error`
 - `timeout`: Request timeout
 
+### Resize Planning
+
+Compute the target dimensions for a VLM input image. Pure math, no image
+dependencies — resize with whatever library your service already uses,
+applying `plan.interpolation`. `name`, `factor`, and `interpolation` come
+from the model server's resize spec; `pixels` is the UI resize option:
+
+```python
+from visionai_sdk_python.vlm import compute_resize
+
+plan = compute_resize(
+    width=1920, height=1080, name="smart_resize", factor=32, pixels=768,
+    interpolation="bicubic",
+)
+# ResizePlan(width=1024, height=576, interpolation='bicubic')
+# smart_resize: dimensions divisible by factor, area capped at pixels * pixels
+
+compute_resize(width=w, height=h, name="square_resize", pixels=384, interpolation="lanczos")
+# square_resize: exact pixels x pixels; factor is ignored, so a whole resize
+# spec can be forwarded as-is
+
+# No resize spec from the model server? Fall back to the default
+# (smart_resize, factor 32, bicubic):
+from visionai_sdk_python.vlm import DEFAULT_RESIZE_SPEC
+plan = compute_resize(width=w, height=h, pixels=768, **DEFAULT_RESIZE_SPEC)
+
+# Apply with your own imaging library (PIL shown; see module docstring for cv2)
+interpolation = {"bicubic": Image.Resampling.BICUBIC,
+                 "lanczos": Image.Resampling.LANCZOS}[plan.interpolation]
+img = img.resize((plan.width, plan.height), interpolation)
+```
+
+Invalid input (non-positive dimensions, a non-integer or non-positive
+`pixels`/`factor`, unknown `name` or `interpolation`, missing `factor` for
+smart resize, `min_pixels` on a square resize or over the pixel budget, an
+unsatisfiable budget) raises `ValueError`.
+
 ## Token Validation
 
 ```python

{visionai_sdk_python-2.0.0 → visionai_sdk_python-2.1.0}/README.md

@@ -9,6 +9,7 @@ Python client library for VisionAI authentication and Vision Language Model (VLM
 - **Auto Token Management**: Automatic token refresh before expiration
 - **JWT Validation**: Built-in token signature and expiration verification
 - **VLM Inference**: Submit and poll vision-language model tasks
+- **Resize Planning**: Compute VLM input dimensions (smart / square resize) without any image dependency — the caller does the actual resize
 - **Async Support**: Full async/await support with `AsyncClient`
 - **Type Safe**: Full type hints with Pydantic validation
 - **Service Source Attribution**: Auto-attach a service-source header to every outbound `requests`/`httpx`/`aiohttp` call with a single startup call
@@ -169,6 +170,43 @@ elif result.status in ("failed", "timeout"):
 - `failed`: Error, check `error`
 - `timeout`: Request timeout
 
+### Resize Planning
+
+Compute the target dimensions for a VLM input image. Pure math, no image
+dependencies — resize with whatever library your service already uses,
+applying `plan.interpolation`. `name`, `factor`, and `interpolation` come
+from the model server's resize spec; `pixels` is the UI resize option:
+
+```python
+from visionai_sdk_python.vlm import compute_resize
+
+plan = compute_resize(
+    width=1920, height=1080, name="smart_resize", factor=32, pixels=768,
+    interpolation="bicubic",
+)
+# ResizePlan(width=1024, height=576, interpolation='bicubic')
+# smart_resize: dimensions divisible by factor, area capped at pixels * pixels
+
+compute_resize(width=w, height=h, name="square_resize", pixels=384, interpolation="lanczos")
+# square_resize: exact pixels x pixels; factor is ignored, so a whole resize
+# spec can be forwarded as-is
+
+# No resize spec from the model server? Fall back to the default
+# (smart_resize, factor 32, bicubic):
+from visionai_sdk_python.vlm import DEFAULT_RESIZE_SPEC
+plan = compute_resize(width=w, height=h, pixels=768, **DEFAULT_RESIZE_SPEC)
+
+# Apply with your own imaging library (PIL shown; see module docstring for cv2)
+interpolation = {"bicubic": Image.Resampling.BICUBIC,
+                 "lanczos": Image.Resampling.LANCZOS}[plan.interpolation]
+img = img.resize((plan.width, plan.height), interpolation)
+```
+
+Invalid input (non-positive dimensions, a non-integer or non-positive
+`pixels`/`factor`, unknown `name` or `interpolation`, missing `factor` for
+smart resize, `min_pixels` on a square resize or over the pixel budget, an
+unsatisfiable budget) raises `ValueError`.
+
 ## Token Validation
 
 ```python

{visionai_sdk_python-2.0.0 → visionai_sdk_python-2.1.0}/src/visionai_sdk_python/vlm/__init__.py

@@ -2,12 +2,24 @@
 
 from .async_resource import AsyncVLMResource
 from .models import NIMRequestModel, ResponseErrorModel, ResponseNormalModel
+from .preprocess import (
+    DEFAULT_RESIZE_SPEC,
+    Interpolation,
+    ResizeMode,
+    ResizePlan,
+    compute_resize,
+)
 from .resource import VLMResource
 
 __all__ = [
+    "DEFAULT_RESIZE_SPEC",
     "AsyncVLMResource",
-    "VLMResource",
+    "Interpolation",
     "NIMRequestModel",
-    "ResponseNormalModel",
+    "ResizeMode",
+    "ResizePlan",
     "ResponseErrorModel",
+    "ResponseNormalModel",
+    "VLMResource",
+    "compute_resize",
 ]

visionai_sdk_python-2.1.0/src/visionai_sdk_python/vlm/preprocess.py

@@ -0,0 +1,186 @@
+"""Image-resize planning helpers for VLM inference.
+
+This module only computes target dimensions (pure math, no image
+dependencies). The mode (``name``), ``factor``, and ``interpolation`` come
+from the model server's resize spec; ``pixels`` comes from the UI resize
+option. The actual resize is done by the caller with whatever imaging
+library its pipeline already uses, applying ``plan.interpolation``:
+
+    plan = compute_resize(
+        width=w, height=h, name="smart_resize", factor=32, pixels=768,
+        interpolation="bicubic",
+    )
+
+    # PIL client
+    PIL_INTERPOLATION = {
+        "bicubic": Image.Resampling.BICUBIC,
+        "lanczos": Image.Resampling.LANCZOS,
+    }
+    out = img.resize((plan.width, plan.height), PIL_INTERPOLATION[plan.interpolation])
+
+    # OpenCV client
+    CV2_INTERPOLATION = {
+        "bicubic": cv2.INTER_CUBIC,
+        "lanczos": cv2.INTER_LANCZOS4,
+    }
+    out = cv2.resize(
+        arr, (plan.width, plan.height), interpolation=CV2_INTERPOLATION[plan.interpolation]
+    )
+"""
+
+import math
+from collections.abc import Mapping
+from types import MappingProxyType
+from typing import Any, Literal, NamedTuple, get_args
+
+_MAX_ASPECT_RATIO = 200
+
+ResizeMode = Literal["smart_resize", "square_resize"]
+Interpolation = Literal["bicubic", "lanczos"]
+
+# Fallback resize spec for when the model server does not provide one.
+# Read-only; splat it into compute_resize alongside the UI pixels value:
+#     compute_resize(width=w, height=h, pixels=768, **DEFAULT_RESIZE_SPEC)
+DEFAULT_RESIZE_SPEC: Mapping[str, Any] = MappingProxyType(
+    {"name": "smart_resize", "factor": 32, "interpolation": "bicubic"}
+)
+
+
+class ResizePlan(NamedTuple):
+    """Target dimensions and interpolation method for a client-side resize."""
+
+    width: int
+    height: int
+    interpolation: Interpolation
+
+
+def _smart_resize(
+    height: int,
+    width: int,
+    factor: int,
+    min_pixels: int,
+    max_pixels: int,
+) -> tuple[int, int]:
+    """Compute target (height, width) — note height-first, unlike ResizePlan.
+
+    1. Both dimensions are divisible by ``factor``.
+    2. The total number of pixels is within [``min_pixels``, ``max_pixels``].
+    3. The aspect ratio is maintained as closely as possible.
+
+    Raises ValueError when the aspect ratio exceeds 200 or the constraints
+    cannot all be satisfied. Argument validation is compute_resize's job.
+    """
+    if max(height, width) / min(height, width) > _MAX_ASPECT_RATIO:
+        raise ValueError(
+            "absolute aspect ratio must be smaller than "
+            f"{_MAX_ASPECT_RATIO}, got {max(height, width) / min(height, width)}"
+        )
+    h_bar = max(factor, round(height / factor) * factor)
+    w_bar = max(factor, round(width / factor) * factor)
+    if h_bar * w_bar > max_pixels:
+        beta = math.sqrt((height * width) / max_pixels)
+        h_bar = max(factor, math.floor(height / beta / factor) * factor)
+        w_bar = max(factor, math.floor(width / beta / factor) * factor)
+    elif h_bar * w_bar < min_pixels:
+        beta = math.sqrt(min_pixels / (height * width))
+        h_bar = math.ceil(height * beta / factor) * factor
+        w_bar = math.ceil(width * beta / factor) * factor
+    if not min_pixels <= h_bar * w_bar <= max_pixels:
+        raise ValueError(
+            f"cannot satisfy min_pixels={min_pixels}, max_pixels={max_pixels} for a "
+            f"{width}x{height} image with factor={factor}"
+        )
+    return h_bar, w_bar
+
+
+def compute_resize(
+    *,
+    width: int,
+    height: int,
+    name: ResizeMode,
+    pixels: int,
+    interpolation: Interpolation,
+    factor: int | None = None,
+    min_pixels: int | None = None,
+) -> ResizePlan:
+    """Plan a VLM-input resize from the model server's resize spec.
+
+    All arguments are keyword-only — a transposed width/height cannot happen
+    silently. ``name``, ``factor``, and ``interpolation`` mirror the model
+    server's resize spec fields; ``pixels`` is the UI resize option value.
+
+    - ``name="smart_resize"`` — dimensions divisible by ``factor``, total
+      pixel count within [``min_pixels``, ``pixels * pixels``], aspect ratio
+      kept. ``factor`` is required (the model's patch size, e.g. 32 or 48);
+      ``min_pixels`` defaults to ``4 * factor * factor``.
+    - ``name="square_resize"`` — exact ``pixels`` x ``pixels``; aspect ratio
+      not preserved. ``factor`` has no meaning and is ignored, so a whole
+      server resize spec can be forwarded as-is.
+
+    Args:
+        width: Source image width in pixels.
+        height: Source image height in pixels.
+        name: Resize mode from the model server: "smart_resize" or
+            "square_resize".
+        pixels: UI pixel option — one number, but its meaning depends on
+            ``name``:
+
+            - ``"smart_resize"``: an area budget, not a side length. The
+              output area is capped at ``pixels * pixels`` while keeping the
+              source aspect ratio, so neither output side is generally equal
+              to ``pixels`` — e.g. ``pixels=768`` on a 1920x1080 frame gives
+              1024x576 (= 589,824 px, the same area as 768x768).
+            - ``"square_resize"``: the exact side length. The output is
+              always ``pixels`` x ``pixels`` — e.g. ``pixels=384`` gives
+              384x384 regardless of the source shape.
+        interpolation: Interpolation the caller should resize with,
+            from the model server: "bicubic" or "lanczos". Passed through
+            into the returned plan.
+        factor: Smart resize only: round dimensions to multiples of this.
+        min_pixels: Smart resize only: lower bound on output pixel count.
+
+    Returns:
+        ResizePlan(width, height, interpolation) — note width-first,
+        matching the (width, height) order PIL and OpenCV resize calls expect.
+
+    Raises:
+        ValueError: If height/width are not positive, ``pixels`` or ``factor``
+            is not a positive integer, ``name`` or ``interpolation`` is not a
+            supported value, ``factor`` is missing (smart), ``min_pixels`` is
+            given for square resize or exceeds the pixel budget, or the
+            constraints cannot be satisfied (extreme aspect ratio).
+    """
+    if height <= 0 or width <= 0:
+        raise ValueError(f"height and width must be positive, got {width}x{height}")
+    if name not in get_args(ResizeMode):
+        raise ValueError(f"name must be one of {get_args(ResizeMode)}, got {name!r}")
+    if interpolation not in get_args(Interpolation):
+        raise ValueError(
+            f"interpolation must be one of {get_args(Interpolation)}, "
+            f"got {interpolation!r}"
+        )
+    if isinstance(pixels, bool) or not isinstance(pixels, int) or pixels <= 0:
+        raise ValueError(f"pixels must be a positive integer, got {pixels!r}")
+
+    if name == "smart_resize":
+        if factor is None:
+            raise ValueError("smart_resize requires factor")
+        if isinstance(factor, bool) or not isinstance(factor, int) or factor <= 0:
+            raise ValueError(f"factor must be a positive integer, got {factor!r}")
+        max_pixels = pixels * pixels
+        if min_pixels is None:
+            min_pixels = 4 * factor * factor
+        if min_pixels <= 0 or min_pixels > max_pixels:
+            raise ValueError(
+                f"min_pixels must be in (0, pixels * pixels], got "
+                f"min_pixels={min_pixels}, pixels={pixels}"
+            )
+        h_bar, w_bar = _smart_resize(height, width, factor, min_pixels, max_pixels)
+    else:
+        # factor is part of the server resize spec, so a caller forwarding the
+        # whole spec may pass it; it has no meaning here, so ignore it.
+        if min_pixels is not None:
+            raise ValueError("min_pixels only applies to smart_resize")
+        w_bar = h_bar = pixels
+
+    return ResizePlan(width=w_bar, height=h_bar, interpolation=interpolation)

{visionai_sdk_python-2.0.0 → visionai_sdk_python-2.1.0}/src/visionai_sdk_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: visionai-sdk-python
-Version: 2.0.0
+Version: 2.1.0
 Summary: VisionAI SDK for Python
 Author-email: Tony Yang <tonyyang@linkervision.com>
 Requires-Python: >=3.11
@@ -27,6 +27,7 @@ Python client library for VisionAI authentication and Vision Language Model (VLM
 - **Auto Token Management**: Automatic token refresh before expiration
 - **JWT Validation**: Built-in token signature and expiration verification
 - **VLM Inference**: Submit and poll vision-language model tasks
+- **Resize Planning**: Compute VLM input dimensions (smart / square resize) without any image dependency — the caller does the actual resize
 - **Async Support**: Full async/await support with `AsyncClient`
 - **Type Safe**: Full type hints with Pydantic validation
 - **Service Source Attribution**: Auto-attach a service-source header to every outbound `requests`/`httpx`/`aiohttp` call with a single startup call
@@ -187,6 +188,43 @@ elif result.status in ("failed", "timeout"):
 - `failed`: Error, check `error`
 - `timeout`: Request timeout
 
+### Resize Planning
+
+Compute the target dimensions for a VLM input image. Pure math, no image
+dependencies — resize with whatever library your service already uses,
+applying `plan.interpolation`. `name`, `factor`, and `interpolation` come
+from the model server's resize spec; `pixels` is the UI resize option:
+
+```python
+from visionai_sdk_python.vlm import compute_resize
+
+plan = compute_resize(
+    width=1920, height=1080, name="smart_resize", factor=32, pixels=768,
+    interpolation="bicubic",
+)
+# ResizePlan(width=1024, height=576, interpolation='bicubic')
+# smart_resize: dimensions divisible by factor, area capped at pixels * pixels
+
+compute_resize(width=w, height=h, name="square_resize", pixels=384, interpolation="lanczos")
+# square_resize: exact pixels x pixels; factor is ignored, so a whole resize
+# spec can be forwarded as-is
+
+# No resize spec from the model server? Fall back to the default
+# (smart_resize, factor 32, bicubic):
+from visionai_sdk_python.vlm import DEFAULT_RESIZE_SPEC
+plan = compute_resize(width=w, height=h, pixels=768, **DEFAULT_RESIZE_SPEC)
+
+# Apply with your own imaging library (PIL shown; see module docstring for cv2)
+interpolation = {"bicubic": Image.Resampling.BICUBIC,
+                 "lanczos": Image.Resampling.LANCZOS}[plan.interpolation]
+img = img.resize((plan.width, plan.height), interpolation)
+```
+
+Invalid input (non-positive dimensions, a non-integer or non-positive
+`pixels`/`factor`, unknown `name` or `interpolation`, missing `factor` for
+smart resize, `min_pixels` on a square resize or over the pixel budget, an
+unsatisfiable budget) raises `ValueError`.
+
 ## Token Validation
 
 ```python

{visionai_sdk_python-2.0.0 → visionai_sdk_python-2.1.0}/src/visionai_sdk_python.egg-info/SOURCES.txt

@@ -33,10 +33,12 @@ src/visionai_sdk_python/vlm/__init__.py
 src/visionai_sdk_python/vlm/_mixin.py
 src/visionai_sdk_python/vlm/async_resource.py
 src/visionai_sdk_python/vlm/models.py
+src/visionai_sdk_python/vlm/preprocess.py
 src/visionai_sdk_python/vlm/resource.py
 tests/__init__.py
 tests/constants.py
 tests/test__base.py
 tests/test_async_client.py
 tests/test_client.py
-tests/test_instrumentation.py
+tests/test_instrumentation.py
+tests/test_vlm_preprocess.py

{visionai_sdk_python-2.0.0 → visionai_sdk_python-2.1.0}/src/visionai_sdk_python.egg-info/scm_file_list.json

@@ -1,39 +1,41 @@
 {
   "files": [
-    "pyproject.toml",
-    "README.md",
-    "uv.lock",
-    ".gitignore",
     ".github/dependabot.yml",
     ".github/workflows/ci.yml",
     ".github/workflows/publish.yml",
-    "tests/test_async_client.py",
-    "tests/test_instrumentation.py",
-    "tests/__init__.py",
-    "tests/test_client.py",
-    "tests/test__base.py",
-    "tests/constants.py",
-    "src/visionai_sdk_python/_base.py",
-    "src/visionai_sdk_python/async_client.py",
-    "src/visionai_sdk_python/endpoints.py",
-    "src/visionai_sdk_python/_source_header.py",
-    "src/visionai_sdk_python/_request_attribution.py",
-    "src/visionai_sdk_python/py.typed",
+    ".gitignore",
+    "README.md",
+    "pyproject.toml",
     "src/visionai_sdk_python/__init__.py",
+    "src/visionai_sdk_python/_base.py",
     "src/visionai_sdk_python/_jwt_verifier.py",
-    "src/visionai_sdk_python/client.py",
-    "src/visionai_sdk_python/exceptions.py",
-    "src/visionai_sdk_python/instrumentation.py",
-    "src/visionai_sdk_python/constants.py",
+    "src/visionai_sdk_python/_request_attribution.py",
+    "src/visionai_sdk_python/_source_header.py",
+    "src/visionai_sdk_python/async_client.py",
     "src/visionai_sdk_python/auth/__init__.py",
+    "src/visionai_sdk_python/auth/_mixin.py",
     "src/visionai_sdk_python/auth/async_resource.py",
-    "src/visionai_sdk_python/auth/resource.py",
     "src/visionai_sdk_python/auth/models.py",
-    "src/visionai_sdk_python/auth/_mixin.py",
+    "src/visionai_sdk_python/auth/resource.py",
+    "src/visionai_sdk_python/client.py",
+    "src/visionai_sdk_python/constants.py",
+    "src/visionai_sdk_python/endpoints.py",
+    "src/visionai_sdk_python/exceptions.py",
+    "src/visionai_sdk_python/instrumentation.py",
+    "src/visionai_sdk_python/py.typed",
     "src/visionai_sdk_python/vlm/__init__.py",
+    "src/visionai_sdk_python/vlm/_mixin.py",
     "src/visionai_sdk_python/vlm/async_resource.py",
-    "src/visionai_sdk_python/vlm/resource.py",
     "src/visionai_sdk_python/vlm/models.py",
-    "src/visionai_sdk_python/vlm/_mixin.py"
+    "src/visionai_sdk_python/vlm/preprocess.py",
+    "src/visionai_sdk_python/vlm/resource.py",
+    "tests/__init__.py",
+    "tests/constants.py",
+    "tests/test__base.py",
+    "tests/test_async_client.py",
+    "tests/test_client.py",
+    "tests/test_instrumentation.py",
+    "tests/test_vlm_preprocess.py",
+    "uv.lock"
   ]
 }

visionai_sdk_python-2.1.0/src/visionai_sdk_python.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "2.1.0",
+  "distance": 0,
+  "node": "g72bde18e5ad7c772f12e7d313f7396f24342ef92",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-09-14"
+}

visionai_sdk_python-2.1.0/tests/test_vlm_preprocess.py

@@ -0,0 +1,213 @@
+"""Tests for VLM image-resize planning helpers."""
+
+import pytest
+
+from visionai_sdk_python.vlm import compute_resize
+
+
+def smart(width, height, **overrides):
+    kwargs = {
+        "width": width,
+        "height": height,
+        "name": "smart_resize",
+        "factor": 32,
+        "pixels": 768,
+        "interpolation": "bicubic",
+    }
+    kwargs.update(overrides)
+    return compute_resize(**kwargs)
+
+
+@pytest.mark.parametrize("factor", [32, 48])
+@pytest.mark.parametrize(
+    "width,height",
+    [
+        (1920, 1080),  # downscale (over the pixel budget)
+        (32, 32),  # tiny, upscale to min_pixels
+        (375, 500),  # within bounds, snap to factor
+        (4000, 3000),  # large downscale
+    ],
+)
+def test_smart_constraints(width, height, factor):
+    plan = smart(width, height, factor=factor)
+    assert plan.width % factor == 0
+    assert plan.height % factor == 0
+    assert 4 * factor * factor <= plan.width * plan.height <= 768 * 768
+
+
+@pytest.mark.parametrize(
+    "width,height,expected",
+    [
+        (1920, 1080, (1024, 576)),  # README example
+        (1280, 8, (1280, 32)),  # thin strip: short side snaps up, long side kept
+        (1000, 17, (992, 32)),  # ...and does not jump at the factor/2 boundary
+        (1000, 16, (992, 32)),
+        (224, 2, (224, 32)),  # already inside the budget — no upscale
+    ],
+)
+def test_smart_golden_dimensions(width, height, expected):
+    # Pins parity with the model server's smart_resize; the constraint-only
+    # tests above pass for wrong-but-legal plans.
+    plan = smart(width, height)
+    assert (plan.width, plan.height) == expected
+
+
+def test_smart_keeps_aspect_ratio():
+    plan = smart(1920, 1080)
+    assert plan.width / plan.height == pytest.approx(1920 / 1080, rel=0.1)
+
+
+def test_smart_orientation_not_transposed():
+    # Landscape in, landscape out — catches any width/height swap regression.
+    plan = smart(1920, 1080)
+    assert plan.width > plan.height
+
+
+def test_smart_rejects_extreme_aspect_ratio():
+    with pytest.raises(ValueError, match="aspect ratio"):
+        smart(2010, 10)
+
+
+def test_smart_rejects_unsatisfiable_max_pixels():
+    # Elongated strip: aspect ratio passes the <=200 check, but the factor
+    # floor cannot fit the pixel budget. Must raise, not silently overshoot.
+    with pytest.raises(ValueError, match="cannot satisfy"):
+        smart(40000, 200, factor=48, pixels=384)
+
+
+def test_smart_rejects_unsatisfiable_min_pixels():
+    # Tight budget + extreme shape floors below min_pixels.
+    with pytest.raises(ValueError, match="cannot satisfy"):
+        smart(20000, 10000, pixels=64)
+
+
+def test_smart_min_pixels_defaults_to_four_patches():
+    plan = smart(32, 32)
+    assert plan.width * plan.height >= 4 * 32 * 32
+    assert plan == smart(32, 32, min_pixels=4 * 32 * 32)
+
+
+def test_smart_requires_factor():
+    with pytest.raises(ValueError, match="requires factor"):
+        compute_resize(
+            width=1920,
+            height=1080,
+            name="smart_resize",
+            pixels=768,
+            interpolation="bicubic",
+        )
+
+
+def test_smart_rejects_min_pixels_over_budget():
+    with pytest.raises(ValueError, match="min_pixels"):
+        smart(1920, 1080, min_pixels=100000, pixels=64)
+    # Implicit default min_pixels (4 * 48 * 48 = 9216) exceeds 64 * 64.
+    with pytest.raises(ValueError, match="min_pixels"):
+        smart(1920, 1080, factor=48, pixels=64)
+
+
+@pytest.mark.parametrize(
+    "kwargs",
+    [{"factor": 0}, {"factor": -32}, {"factor": 32.5}, {"min_pixels": 0}],
+)
+def test_smart_rejects_bad_params(kwargs):
+    with pytest.raises(ValueError):
+        smart(1920, 1080, **kwargs)
+
+
+def test_square():
+    plan = compute_resize(
+        width=1920,
+        height=1080,
+        name="square_resize",
+        pixels=384,
+        interpolation="lanczos",
+    )
+    assert (plan.width, plan.height) == (384, 384)
+    assert plan.interpolation == "lanczos"
+
+
+def test_square_ignores_factor():
+    # factor comes from the server resize spec, so forwarding the whole spec
+    # must not blow up on a square model.
+    plan = compute_resize(
+        width=1920,
+        height=1080,
+        name="square_resize",
+        pixels=384,
+        factor=32,
+        interpolation="bicubic",
+    )
+    assert (plan.width, plan.height) == (384, 384)
+
+
+def test_square_rejects_min_pixels():
+    with pytest.raises(ValueError, match="only applies to smart_resize"):
+        compute_resize(
+            width=1920,
+            height=1080,
+            name="square_resize",
+            pixels=384,
+            min_pixels=100,
+            interpolation="bicubic",
+        )
+
+
+def test_positional_arguments_rejected():
+    with pytest.raises(TypeError):
+        compute_resize(
+            1920, 1080, name="square_resize", pixels=384, interpolation="lanczos"
+        )  # type: ignore[misc]
+
+
+@pytest.mark.parametrize("width,height", [(0, 1080), (1920, 0), (0, 0), (-1, 100)])
+def test_rejects_non_positive_dimensions(width, height):
+    with pytest.raises(ValueError, match="height and width"):
+        smart(width, height)
+
+
+@pytest.mark.parametrize("pixels", [0, -384, 384.0, True, "384"])
+def test_rejects_bad_pixels(pixels):
+    # 384.0 is what a JSON-decoded UI option looks like; no imaging library
+    # accepts float dimensions, so reject at the boundary, not downstream.
+    with pytest.raises(ValueError, match="pixels must be a positive integer"):
+        compute_resize(
+            width=1920,
+            height=1080,
+            name="square_resize",
+            pixels=pixels,
+            interpolation="bicubic",
+        )
+
+
+def test_rejects_unknown_name():
+    with pytest.raises(ValueError, match="name must be one of"):
+        compute_resize(
+            width=1920,
+            height=1080,
+            name="longest_edge",
+            pixels=768,
+            interpolation="bicubic",
+        )
+
+
+def test_rejects_unknown_interpolation():
+    # bilinear is no longer a supported value.
+    with pytest.raises(ValueError, match="interpolation must be one of"):
+        smart(1920, 1080, interpolation="bilinear")
+
+
+def test_default_resize_spec():
+    from visionai_sdk_python.vlm import DEFAULT_RESIZE_SPEC
+
+    plan = compute_resize(width=1920, height=1080, pixels=768, **DEFAULT_RESIZE_SPEC)
+    assert plan == compute_resize(
+        width=1920,
+        height=1080,
+        pixels=768,
+        name="smart_resize",
+        factor=32,
+        interpolation="bicubic",
+    )
+    with pytest.raises(TypeError):
+        DEFAULT_RESIZE_SPEC["factor"] = 48  # type: ignore[index]

visionai_sdk_python-2.0.0/src/visionai_sdk_python.egg-info/scm_version.json

@@ -1,8 +0,0 @@
-{
-  "tag": "2.0.0",
-  "distance": 0,
-  "node": "ge6183ee40ad92d5fc80df4dd82c92fa4843d782a",
-  "dirty": false,
-  "branch": "HEAD",
-  "node_date": "2026-08-07"
-}