Spaces:
Running on Zero
Running on Zero
Download tests/test_transformers_compat.py from broyang/3dai: direct link, hf CLI and curl.
- Browser
- Download file 5.57 kB
-
https://huggingface.co/spaces/broyang/3dai/resolve/main/tests/test_transformers_compat.py
- Command line
-
hf download hf://spaces/broyang/3dai/tests/test_transformers_compat.py
-
curl -L -o test_transformers_compat.py https://huggingface.co/spaces/broyang/3dai/resolve/main/tests/test_transformers_compat.py
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) | |
| 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() | |