3dai / tests /test_transformers_compat.py
Bobby
Fix Hugging Face SDK wheel installation and Pydantic extras
3adc1d1
Raw History Blame Contribute Delete
5.57 kB
import ast
import hashlib
import importlib.metadata
import os
import re
import sys
import unittest
from pathlib import Path
from urllib.parse import urlparse
from packaging.requirements import Requirement
from packaging.version import Version
ROOT = Path(__file__).resolve().parent.parent
sys.path.insert(0, str(ROOT))
REQUIREMENTS = ROOT / "requirements.txt"
PIPELINE = ROOT / "trellis" / "pipelines" / "trellis_image_to_3d_cpu.py"
RMBG_MODEL = "briaai/RMBG-2.0"
def pinned(name):
pattern = re.compile(rf"^{re.escape(name)}==", re.MULTILINE)
for line in REQUIREMENTS.read_text().splitlines():
if pattern.match(line.strip()):
return line.strip().split("==", 1)[1]
return None
def declared_range(distribution, dependency):
for entry in importlib.metadata.requires(distribution) or []:
requirement = Requirement(entry)
if requirement.name.lower() == dependency and not requirement.marker:
return requirement.specifier
return None
class RequirementsPinTest(unittest.TestCase):
def test_gradio_pinned_to_six(self):
self.assertEqual(pinned("gradio"), "6.27.0")
def test_transformers_pinned_to_five(self):
version = pinned("transformers")
self.assertIsNotNone(version)
self.assertEqual(Version(version).major, 5)
def test_space_build_uses_an_immutable_wheel_url(self):
url = next(line for line in REQUIREMENTS.read_text().splitlines() if "gradio_litmodel3d-" in line)
parsed = urlparse(url)
self.assertEqual(parsed.scheme, "https")
self.assertRegex(parsed.path, r"/resolve/[0-9a-f]{40}/wheels/")
wheel = ROOT / "wheels" / Path(parsed.path).name
self.assertEqual(parsed.fragment, "sha256=" + hashlib.sha256(wheel.read_bytes()).hexdigest())
def test_pydantic_pin_satisfies_space_sdk_extras(self):
version = Version(pinned("pydantic"))
requirements = [Requirement(entry) for entry in importlib.metadata.requires("gradio")]
for requirement in requirements:
if requirement.name == "pydantic" and (
not requirement.marker or requirement.marker.evaluate({"extra": "mcp"})
):
self.assertIn(version, requirement.specifier)
class HubResolutionTest(unittest.TestCase):
def test_gradio_and_transformers_share_one_hub_version(self):
hub = Version(importlib.metadata.version("huggingface-hub"))
for distribution in ("gradio", "transformers"):
specifier = declared_range(distribution, "huggingface-hub")
self.assertIsNotNone(specifier, distribution)
self.assertIn(hub, specifier, f"{distribution} rejects huggingface-hub {hub}")
def test_transformers_accepts_installed_torch(self):
torch = Version(importlib.metadata.version("torch"))
specifier = declared_range("transformers", "torch")
if specifier is not None:
self.assertIn(torch, specifier)
class TransformersSurfaceTest(unittest.TestCase):
def test_model_classes_import(self):
from transformers import ( # noqa: F401
AutoModel,
AutoModelForImageSegmentation,
AutoTokenizer,
CLIPTextModel,
PretrainedConfig,
PreTrainedModel,
)
def test_pipeline_loads_rmbg_with_auto_class(self):
tree = ast.parse(PIPELINE.read_text())
calls = [
node
for node in ast.walk(tree)
if isinstance(node, ast.Call)
and isinstance(node.func, ast.Attribute)
and node.func.attr == "from_pretrained"
and isinstance(node.func.value, ast.Name)
and node.func.value.id == "AutoModelForImageSegmentation"
]
self.assertTrue(calls)
self.assertIn(RMBG_MODEL, PIPELINE.read_text())
keywords = {keyword.arg: keyword for keyword in calls[0].keywords}
self.assertIn("trust_remote_code", keywords)
self.assertTrue(keywords["trust_remote_code"].value.value)
def test_text_pipeline_conditioning_imports(self):
source = (ROOT / "trellis" / "pipelines" / "trellis_text_to_3d.py").read_text()
self.assertIn("from transformers import CLIPTextModel, AutoTokenizer", source)
@unittest.skipUnless(
os.environ.get("TRANSFORMERS_COMPAT_MODEL_CHECK") == "1",
"TRANSFORMERS_COMPAT_MODEL_CHECK=1 downloads and runs RMBG-2.0",
)
class RmbgModelLoadTest(unittest.TestCase):
def test_rmbg_loads_and_segments(self):
import threading
import numpy as np
import torch
from PIL import Image
from trellis.pipelines.trellis_image_to_3d_cpu import TrellisImageTo3DPipeline
pipeline = TrellisImageTo3DPipeline.__new__(TrellisImageTo3DPipeline)
pipeline.rmbg_model_lock = threading.Lock()
pipeline._init_rmbg_model()
source = Image.open(ROOT / "assets" / "example_image" / "bearcat-g5.png").convert("RGB")
result = pipeline.preprocess_images([source])
self.assertEqual(len(result), 1)
self.assertEqual(result[0].size, (518, 518))
array = np.array(result[0])
self.assertEqual(array.shape, (518, 518, 3))
foreground = float((array.sum(axis=2) > 0).mean())
self.assertGreater(foreground, 0.05)
self.assertLess(foreground, 0.95)
expected = "cuda" if torch.cuda.is_available() else "cpu"
self.assertEqual(next(pipeline.rmbg_model.parameters()).device.type, expected)
if __name__ == "__main__":
unittest.main()