truss 0.10.0rc1__py3-none-any.whl → 0.60.0__py3-none-any.whl

truss/tests/test_model_schema.py

@@ -4,9 +4,11 @@ from pathlib import Path
 
 import pytest
 import requests
+
+from truss.templates.shared import serialization
 from truss.tests.helpers import create_truss
 from truss.tests.test_testing_utilities_for_other_tests import ensure_kill_all
-from truss.truss_handle import TrussHandle
+from truss.truss_handle.truss_handle import TrussHandle
 
 DEFAULT_CONFIG = """model_name: test-truss"""
 TRUSS_SERVER_ADDR = "http://localhost:8090"
@@ -15,10 +17,8 @@ SCHEMA_URL = f"{TRUSS_SERVER_ADDR}/v1/models/model/schema"
 
 
 @pytest.mark.integration
-def test_truss_with_no_annotations():
-    truss_root = Path(__file__).parent.parent.parent.resolve()
-
-    truss_dir = truss_root / "truss" / "test_data" / "test_basic_truss"
+def test_truss_with_no_annotations(test_data_path):
+    truss_dir = test_data_path / "test_basic_truss"
 
     tr = TrussHandle(truss_dir)
 
@@ -26,14 +26,14 @@ def test_truss_with_no_annotations():
         _ = tr.docker_run(local_port=8090, detach=True, wait_for_server_ready=True)
 
         response = requests.post(INFERENCE_URL, json={"prompt": "value"})
-        assert response.json() == {
-            "prompt": "value",
-        }
+        assert response.json() == {"prompt": "value"}
 
         schema_response = requests.get(SCHEMA_URL)
         assert schema_response.status_code == 404
 
         assert schema_response.json()["error"] == "No schema found"
+        assert schema_response.headers["x-baseten-error-source"] == "04"
+        assert schema_response.headers["x-baseten-error-code"] == "600"
 
 
 @pytest.mark.integration
@@ -57,8 +57,9 @@ class Model:
 
         schema_response = requests.get(SCHEMA_URL)
         assert schema_response.status_code == 404
-
         assert schema_response.json()["error"] == "No schema found"
+        assert schema_response.headers["x-baseten-error-source"] == "04"
+        assert schema_response.headers["x-baseten-error-code"] == "600"
 
 
 @pytest.mark.integration
@@ -92,40 +93,48 @@ class Model:
 
 
 @pytest.mark.integration
-def test_truss_with_annotated_inputs_outputs():
-    truss_root = Path(__file__).parent.parent.resolve()
-
-    truss_dir = truss_root / "test_data" / "annotated_types_truss"
+def test_truss_with_annotated_inputs_outputs(test_data_path):
+    truss_dir = test_data_path / "annotated_types_truss"
 
     tr = TrussHandle(truss_dir)
 
     with ensure_kill_all():
         _ = tr.docker_run(local_port=8090, detach=True, wait_for_server_ready=True)
+        # Valid JSON input.
+        json_input = {"prompt": "value"}
+        response = requests.post(INFERENCE_URL, json=json_input)
+        assert response.json() == {"generated_text": "value"}
 
-        response = requests.post(INFERENCE_URL, json={"prompt": "value"})
-        assert response.json() == {
-            "generated_text": "value",
-        }
+        # Valid binary input.
+        byte_input = serialization.truss_msgpack_serialize(json_input)
+        print(byte_input)
+        response = requests.post(
+            INFERENCE_URL,
+            data=byte_input,
+            headers={"Content-Type": "application/octet-stream"},
+        )
+        assert response.content == b"\x81\xaegenerated_text\xa5value"
 
         # An invalid input
-
         response = requests.post(INFERENCE_URL, json={"bad_key": "value"})
-
         assert response.status_code == 400
         assert "error" in response.json()
-        assert "Request Validation Error" in response.json()["error"]
+        assert (
+            "Input Parsing Error:\n  `prompt`: Field required."
+            in response.json()["error"]
+        )
+        assert response.headers["x-baseten-error-source"] == "04"
+        assert response.headers["x-baseten-error-code"] == "700"
 
+        # Schema response.
         schema_response = requests.get(SCHEMA_URL)
-
         schema = schema_response.json()
-
         assert schema["input_schema"] == {
             "properties": {"prompt": {"title": "Prompt", "type": "string"}},
             "required": ["prompt"],
             "title": "ModelInput",
             "type": "object",
         }
-
         assert schema["output_schema"] == {
             "properties": {
                 "generated_text": {"title": "Generated Text", "type": "string"}
@@ -442,9 +451,7 @@ class Model:
         schema = schema_response.json()
 
         assert schema["input_schema"] == {
-            "properties": {
-                "prompt": {"title": "Prompt", "type": "string"},
-            },
+            "properties": {"prompt": {"title": "Prompt", "type": "string"}},
             "required": ["prompt"],
             "title": "ModelInput",
             "type": "object",

truss/tests/test_testing_utilities_for_other_tests.py

@@ -1,15 +1,15 @@
 # This file contains shared code to be used in other tests
 # TODO(pankaj): Using a tests file for shared code is not ideal, we should
 # move it to a regular file. This is a short term hack.
-
+import json
+import logging
 import shutil
 import subprocess
 import time
 from contextlib import contextmanager
 
-from truss.build import kill_all
-from truss.constants import TRUSS
-from truss.docker import get_containers
+from truss.base.constants import TRUSS
+from truss.util.docker import get_containers, kill_all
 
 DISK_SPACE_LOW_PERCENTAGE = 20
 
@@ -17,12 +17,57 @@ DISK_SPACE_LOW_PERCENTAGE = 20
 @contextmanager
 def ensure_kill_all():
     try:
-        yield
+        with _show_container_logs_if_raised():
+            yield
     finally:
         kill_all_with_retries()
         ensure_free_disk_space()
 
 
+def _human_readable_json_logs(raw_logs: str) -> str:
+    output = []
+    for line in raw_logs.splitlines():
+        try:
+            log_entry = json.loads(line)
+            human_readable_log = " ".join(
+                f"{key}: {value}" for key, value in log_entry.items()
+            )
+            output.append(f"\t{human_readable_log}")
+        except Exception:
+            output.append(line)
+    return "\n".join(output)
+
+
+@contextmanager
+def _show_container_logs_if_raised():
+    initial_ids = {c.id for c in get_containers({TRUSS: True})}
+    exception_raised = False
+    try:
+        yield
+    except Exception:
+        exception_raised = True
+        raise
+    finally:
+        if exception_raised:
+            print("An exception was raised, showing logs of all containers.")
+            containers = get_containers({TRUSS: True})
+            new_containers = [c for c in containers if c.id not in initial_ids]
+            parts = ["\n"]
+            for container in new_containers:
+                parts.append(f"Logs for container {container.name} ({container.id}):")
+                parts.append(_human_readable_json_logs(container.logs()))
+                parts.append("\n")
+            logging.warning("\n".join(parts))
+
+
+def get_container_logs_from_prefix(prefix: str) -> str:
+    containers = get_containers({TRUSS: True})
+    for container in containers:
+        if container.name.startswith(prefix):
+            return _human_readable_json_logs(container.logs())
+    return ""
+
+
 def kill_all_with_retries(num_retries: int = 10):
     kill_all()
     attempts = 0

truss/tests/test_truss_gatherer.py

@@ -1,8 +1,8 @@
 from pathlib import Path
 from typing import List
 
-from truss.patch.dir_signature import directory_content_signature
-from truss.truss_gatherer import gather
+from truss.truss_handle.patch.dir_signature import directory_content_signature
+from truss.truss_handle.truss_gatherer import gather
 
 
 def test_gather(custom_model_with_external_package):
@@ -21,9 +21,7 @@ def test_gather(custom_model_with_external_package):
     ext_pkg_top_module2.unlink()
 
     assert _same_dir_content(
-        custom_model_with_external_package,
-        gathered_truss_path,
-        ["config.yaml"],
+        custom_model_with_external_package, gathered_truss_path, ["config.yaml"]
     )
 
 

truss/tests/test_truss_handle.py

@@ -7,16 +7,24 @@ import pytest
 import requests
 from python_on_whales.exceptions import DockerException
 from tenacity import RetryError
-from truss.docker import Docker, DockerStates
-from truss.errors import ContainerIsDownError, ContainerNotFoundError
+
+from truss.base.custom_types import Example
+from truss.base.errors import ContainerIsDownError, ContainerNotFoundError
+from truss.base.truss_config import map_local_to_supported_python_version
 from truss.local.local_config_handler import LocalConfigHandler
-from truss.server.control.patch.types import Action, ModelCodePatch, Patch, PatchType
+from truss.templates.control.control.helpers.custom_types import (
+    Action,
+    ModelCodePatch,
+    Patch,
+    PatchType,
+)
 from truss.tests.test_testing_utilities_for_other_tests import (
     ensure_kill_all,
     kill_all_with_retries,
 )
-from truss.truss_handle import TrussHandle, wait_for_truss
-from truss.types import Example, PatchRequest
+from truss.truss_handle.patch.custom_types import PatchRequest
+from truss.truss_handle.truss_handle import TrussHandle, wait_for_truss
+from truss.util.docker import Docker, DockerStates
 
 
 def test_spec(custom_model_truss_dir_with_pre_and_post):
@@ -51,16 +59,18 @@ def test_server_predict(custom_model_truss_dir_with_pre_and_post):
     assert resp == {"predictions": [4, 5, 6, 7]}
 
 
-def test_readme_generation_int_example(custom_model_truss_dir_with_pre_and_post):
+def test_readme_generation_int_example(
+    test_data_path, custom_model_truss_dir_with_pre_and_post
+):
     th = TrussHandle(custom_model_truss_dir_with_pre_and_post)
     readme_contents = th.generate_readme()
     readme_contents = readme_contents.replace("\n", "")
-    correct_readme_contents = _read_readme("readme_int_example.md")
+    correct_readme_contents = _read_readme(test_data_path / "readme_int_example.md")
     assert readme_contents == correct_readme_contents
 
 
 def test_readme_generation_no_example(
-    custom_model_truss_dir_with_pre_and_post_no_example,
+    test_data_path, custom_model_truss_dir_with_pre_and_post_no_example
 ):
     th = TrussHandle(custom_model_truss_dir_with_pre_and_post_no_example)
     if os.path.exists(th._spec.examples_path):
@@ -68,17 +78,17 @@ def test_readme_generation_no_example(
         os.remove(th._spec.examples_path)
     readme_contents = th.generate_readme()
     readme_contents = readme_contents.replace("\n", "")
-    correct_readme_contents = _read_readme("readme_no_example.md")
+    correct_readme_contents = _read_readme(test_data_path / "readme_no_example.md")
     assert readme_contents == correct_readme_contents
 
 
 def test_readme_generation_str_example(
-    custom_model_truss_dir_with_pre_and_post_str_example,
+    test_data_path, custom_model_truss_dir_with_pre_and_post_str_example
 ):
     th = TrussHandle(custom_model_truss_dir_with_pre_and_post_str_example)
     readme_contents = th.generate_readme()
     readme_contents = readme_contents.replace("\n", "")
-    correct_readme_contents = _read_readme("readme_str_example.md")
+    correct_readme_contents = _read_readme(test_data_path / "readme_str_example.md")
     assert readme_contents == correct_readme_contents
 
 
@@ -96,6 +106,7 @@ def test_build_docker_image(custom_model_truss_dir_with_pre_and_post):
     [
         ("baseten/truss-server-base:3.9-v0.4.8rc4", "/usr/local/bin/python3", False),
         ("python:3.8", "/usr/local/bin/python3", False),
+        ("python:3.10", "/usr/local/bin/python3", False),
         ("python:3.11", "/usr/local/bin/python3", False),
         ("python:alpine", "/usr/local/bin/python3", True),
         ("python:2.7-slim", "/usr/local/bin/python", True),
@@ -389,15 +400,10 @@ def test_enable_gpu(custom_model_truss_dir_with_pre_and_post):
 
 @pytest.mark.parametrize(
     "python_version, expected_python_version",
-    [
-        ("3.8", "py38"),
-        ("py38", "py38"),
-    ],
+    [("3.8", "py38"), ("py38", "py38"), ("3.9", "py39"), ("py39", "py39")],
 )
 def test_update_python_version(
-    python_version,
-    expected_python_version,
-    custom_model_truss_dir_with_pre_and_post,
+    python_version, expected_python_version, custom_model_truss_dir_with_pre_and_post
 ):
     th = TrussHandle(custom_model_truss_dir_with_pre_and_post)
     th.update_python_version(python_version)
@@ -406,10 +412,7 @@ def test_update_python_version(
 
 def test_update_requirements(custom_model_truss_dir_with_pre_and_post):
     th = TrussHandle(custom_model_truss_dir_with_pre_and_post)
-    requirements = [
-        "tensorflow==2.3.1",
-        "uvicorn==0.12.2",
-    ]
+    requirements = ["tensorflow==2.3.1", "uvicorn==0.12.2"]
     th.update_requirements(requirements)
     sc_requirements = th.spec.requirements
     assert sc_requirements == requirements
@@ -425,10 +428,7 @@ def test_update_requirements_from_file(
         "    # this is comment with a big space. Please don't add.",
         "uvicorn==0.12.2",
     ]
-    allowed_requirements = [
-        "tensorflow==2.3.1",
-        "uvicorn==0.12.2",
-    ]
+    allowed_requirements = ["tensorflow==2.3.1", "uvicorn==0.12.2"]
     req_file_path = tmp_path / "requirements.txt"
     with req_file_path.open("w") as req_file:
         for req in file_requirements:
@@ -450,6 +450,25 @@ def test_add_environment_variable(custom_model_truss_dir_with_pre_and_post):
         Docker.client().kill(container)
 
 
+@pytest.mark.integration
+def test_build_commands(test_data_path):
+    truss_dir = test_data_path / "test_build_commands"
+    tr = TrussHandle(truss_dir)
+    with ensure_kill_all():
+        r1 = tr.docker_predict([1, 2])
+        assert r1 == {"predictions": [1, 2]}
+
+
+@pytest.mark.integration
+def test_build_commands_failure(test_data_path):
+    truss_dir = test_data_path / "test_build_commands_failure"
+    tr = TrussHandle(truss_dir)
+    try:
+        tr.docker_run(local_port=8090, detach=True, wait_for_server_ready=True)
+    except DockerException as exc:
+        assert "It returned with code 1" in str(exc)
+
+
 def test_add_data_file(custom_model_truss_dir_with_pre_and_post, tmp_path):
     th = TrussHandle(custom_model_truss_dir_with_pre_and_post)
     data_filepath = tmp_path / "test_data.txt"
@@ -513,18 +532,13 @@ def test_add_example_new(custom_model_truss_dir_with_pre_and_post):
     th = TrussHandle(custom_model_truss_dir_with_pre_and_post)
     orig_examples = th.examples()
     th.add_example("example2", [[1]])
-    assert th.examples() == [
-        *orig_examples,
-        Example("example2", [[1]]),
-    ]
+    assert th.examples() == [*orig_examples, Example("example2", [[1]])]
 
 
 def test_add_example_update(custom_model_truss_dir_with_pre_and_post):
     th = TrussHandle(custom_model_truss_dir_with_pre_and_post)
     th.add_example("example1", [[1]])
-    assert th.examples() == [
-        Example("example1", [[1]]),
-    ]
+    assert th.examples() == [Example("example1", [[1]])]
 
 
 def test_model_without_pre_post(custom_model_truss_dir):
@@ -562,11 +576,9 @@ class Model:
                 Patch(
                     type=PatchType.MODEL_CODE,
                     body=ModelCodePatch(
-                        action=Action.UPDATE,
-                        path="model.py",
-                        content=new_model_code,
+                        action=Action.UPDATE, path="model.py", content=new_model_code
                     ),
-                ),
+                )
             ],
         )
 
@@ -604,10 +616,9 @@ class Model:
         assert len(th.get_all_docker_images()) == orig_num_truss_images + 1
 
 
-@patch("truss.truss_handle.directory_content_hash")
+@patch("truss.truss_handle.truss_handle.directory_content_hash")
 def test_truss_hash_caching_based_on_max_mod_time(
-    directory_content_patcher,
-    custom_model_truss_dir,
+    directory_content_patcher, custom_model_truss_dir
 ):
     directory_content_patcher.return_value = "mock_hash"
     th = TrussHandle(custom_model_truss_dir)
@@ -623,14 +634,14 @@ def test_truss_hash_caching_based_on_max_mod_time(
     directory_content_patcher.call_count == 2
 
 
-@patch("truss.truss_handle.get_container_state")
+@patch("truss.truss_handle.truss_handle.get_container_state")
 def test_container_oom_caught_during_waiting(container_state_mock):
     container_state_mock.return_value = DockerStates.OOMKILLED
     with pytest.raises(ContainerIsDownError):
         wait_for_truss(url="localhost:8000", container=MagicMock())
 
 
-@patch("truss.truss_handle.get_container_state")
+@patch("truss.truss_handle.truss_handle.get_container_state")
 @pytest.mark.integration
 def test_container_stuck_in_created(container_state_mock):
     container_state_mock.return_value = DockerStates.CREATED
@@ -674,10 +685,7 @@ class Model:
 @pytest.mark.integration
 @pytest.mark.parametrize(
     "patch_path, expected_call_count",
-    [
-        ("hash_is_current", 1),
-        ("hash_is_current_but_only_every_third_call_succeeds", 3),
-    ],
+    [("hash_is_current", 1), ("hash_is_current_but_only_every_third_call_succeeds", 3)],
 )
 def test_patch_ping_flow(
     patch_path, expected_call_count, custom_model_control, patch_ping_test_server
@@ -687,11 +695,7 @@ def test_patch_ping_flow(
     th = TrussHandle(custom_model_control)
     tag = "test-docker-custom-model-control-tag:0.0.1"
     with ensure_kill_all():
-        result = th.docker_predict(
-            [1],
-            tag=tag,
-            patch_ping_url=patch_ping_url,
-        )
+        result = th.docker_predict([1], tag=tag, patch_ping_url=patch_ping_url)
         assert result == [1]
 
         # Make sure the patch ping url was actually hit
@@ -775,28 +779,27 @@ def verify_python_requirement_not_installed_on_container(container, req: str):
 
 
 def verify_environment_variable_on_container(
-    container,
-    env_var_name: str,
-    env_var_value: str,
+    container, env_var_name: str, env_var_value: str
 ):
     resp = container.execute(["env"])
     needle = f"{env_var_name}={env_var_value}"
     assert needle in resp.splitlines()
 
 
-def _read_readme(filename: str) -> str:
-    readme_correct_path = Path(__file__).parent.parent / "test_data" / filename
-    readme_contents = readme_correct_path.open().read().replace("\n", "")
-    return readme_contents
+def _read_readme(readme_correct_path: Path) -> str:
+    return readme_correct_path.open().read().replace("\n", "")
 
 
 def generate_default_config():
+    # The test fixture varies with host version.
+    python_version = map_local_to_supported_python_version()
     config = {
+        "build_commands": [],
         "environment_variables": {},
         "external_package_dirs": [],
         "model_metadata": {},
         "model_name": None,
-        "python_version": "py39",
+        "python_version": python_version,
         "requirements": [],
         "resources": {
             "accelerator": None,

truss/tests/test_util.py

@@ -2,7 +2,8 @@ import os
 from unittest.mock import patch
 
 import requests_mock
-from truss.truss_config import ExternalData
+
+from truss.base.truss_config import ExternalData
 from truss.util.download import download_external_data
 
 TEST_DOWNLOAD_URL = "http://example.com/some-download-url"

truss/tests/test_validation.py

@@ -1,6 +1,7 @@
 import pytest
-from truss.errors import ValidationError
-from truss.validation import (
+
+from truss.base.errors import ValidationError
+from truss.base.validation import (
     validate_cpu_spec,
     validate_memory_spec,
     validate_secret_name,
@@ -64,21 +65,22 @@ def test_validate_cpu_spec(cpu_spec, expected_valid):
 
 
 @pytest.mark.parametrize(
-    "mem_spec, expected_valid",
+    "mem_spec, expected_valid, memory_in_bytes",
     [
-        (None, False),
-        (1, False),
-        ("1m", False),
-        ("1k", True),
-        ("512k", True),
-        ("512M", True),
-        ("1.5Gi", True),
-        ("abc", False),
+        (None, False, None),
+        (1, False, None),
+        ("1m", False, None),
+        ("1k", True, 10**3),
+        ("512k", True, 512 * 10**3),
+        ("512M", True, 512 * 10**6),
+        ("1.5Gi", True, 1.5 * 1024**3),
+        ("abc", False, None),
+        ("1024", True, 1024),
     ],
 )
-def test_validate_mem_spec(mem_spec, expected_valid):
+def test_validate_mem_spec(mem_spec, expected_valid, memory_in_bytes):
     if not expected_valid:
         with pytest.raises(ValidationError):
             validate_memory_spec(mem_spec)
     else:
-        validate_memory_spec(mem_spec)
+        assert memory_in_bytes == validate_memory_spec(mem_spec)

truss/tests/trt_llm/test_trt_llm_config.py

@@ -0,0 +1,41 @@
+from truss.base.trt_llm_config import (
+    TRTLLMConfiguration,
+    TrussTRTLLMBatchSchedulerPolicy,
+    TrussTRTLLMBuildConfiguration,
+    TrussTRTLLMRuntimeConfiguration,
+)
+
+
+def test_trt_llm_config_init_from_pydantic_models(trtllm_config):
+    build_config = TrussTRTLLMBuildConfiguration(**trtllm_config["trt_llm"]["build"])
+    TRTLLMConfiguration(build=build_config, runtime=TrussTRTLLMRuntimeConfiguration())
+
+
+def test_trt_llm_configuration_init_and_migrate_deprecated_runtime_fields(
+    deprecated_trtllm_config,
+):
+    trt_llm_config = TRTLLMConfiguration(**deprecated_trtllm_config["trt_llm"])
+    assert trt_llm_config.runtime.model_dump() == {
+        "kv_cache_free_gpu_mem_fraction": 0.1,
+        "kv_cache_host_memory_bytes": None,
+        "enable_chunked_context": True,
+        "batch_scheduler_policy": TrussTRTLLMBatchSchedulerPolicy.MAX_UTILIZATION.value,
+        "request_default_max_tokens": 10,
+        "total_token_limit": 50,
+    }
+
+
+def test_trt_llm_configuration_init_and_migrate_deprecated_runtime_fields_existing_runtime(
+    deprecated_trtllm_config_with_runtime_existing,
+):
+    trt_llm_config = TRTLLMConfiguration(
+        **deprecated_trtllm_config_with_runtime_existing["trt_llm"]
+    )
+    assert trt_llm_config.runtime.model_dump() == {
+        "kv_cache_free_gpu_mem_fraction": 0.1,
+        "kv_cache_host_memory_bytes": None,
+        "enable_chunked_context": True,
+        "batch_scheduler_policy": TrussTRTLLMBatchSchedulerPolicy.MAX_UTILIZATION.value,
+        "request_default_max_tokens": 10,
+        "total_token_limit": 100,
+    }

truss/tests/trt_llm/test_validation.py

@@ -0,0 +1,91 @@
+import pytest
+from truss.base.errors import ValidationError
+from truss.base.truss_spec import TrussSpec
+from truss.trt_llm.validation import _verify_has_class_init_arg, validate
+
+
+@pytest.mark.parametrize(
+    "src, class_name, expected_arg, expected_to_raise",
+    [
+        (
+            """
+class Model:
+    def __init__(self, foo):
+        pass
+            """,
+            "Model",
+            "foo",
+            False,
+        ),
+        # Missing arg
+        (
+            """
+class Model:
+    def __init__(self, foo):
+        pass
+            """,
+            "Model",
+            "bar",
+            True,
+        ),
+        # Missing class
+        (
+            """
+class Model:
+    def __init__(self, foo):
+        pass
+            """,
+            "Missing",
+            "bar",
+            True,
+        ),
+        # With default value should still work
+        (
+            """
+class Model:
+    def __init__(self, foo=None):
+        pass
+            """,
+            "Model",
+            "foo",
+            False,
+        ),
+        # not the only arg
+        (
+            """
+class Model:
+    def __init__(self, first, foo, third):
+        pass
+            """,
+            "Model",
+            "foo",
+            False,
+        ),
+    ],
+)
+def test_has_class_init_arg(src, expected_arg, class_name, expected_to_raise):
+    if expected_to_raise:
+        with pytest.raises(ValidationError):
+            _verify_has_class_init_arg(src, class_name, expected_arg)
+    else:
+        _verify_has_class_init_arg(src, class_name, expected_arg)
+
+
+def test_validate(custom_model_trt_llm):
+    spec = TrussSpec(custom_model_trt_llm)
+    validate(spec)
+
+    # overwrite with model code that doesn't take trt_llm as input
+    override_model_code_invalid = """
+class Model:
+    def __init__(self):
+        pass
+"""
+    spec.model_class_filepath.write_text(override_model_code_invalid)
+    new_spec = TrussSpec(custom_model_trt_llm)
+    with pytest.raises(ValidationError):
+        validate(new_spec)
+
+    # If model class file is removed, it should be ok
+    spec.model_class_filepath.unlink()
+    validate(new_spec)