truss 0.9.12.dev2__tar.gz → 0.9.13__tar.gz

{truss-0.9.12.dev2 → truss-0.9.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: truss
-Version: 0.9.12.dev2
+Version: 0.9.13
 Summary: A seamless bridge from model development to model delivery
 Home-page: https://github.com/basetenlabs/truss
 License: MIT

{truss-0.9.12.dev2 → truss-0.9.13}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "truss"
-version = "0.9.12dev2"
+version = "0.9.13"
 description = "A seamless bridge from model development to model delivery"
 license = "MIT"
 readme = "README.md"
@@ -117,7 +117,7 @@ src_paths = ["isort", "test"]
 [tool.mypy]
 ignore_missing_imports = true
 python_version = "3.9"
-
+plugins = ["pydantic.mypy"]
 
 [tool.pytest.ini_options]
 markers = [

{truss-0.9.12.dev2 → truss-0.9.13}/truss/cli/cli.py

@@ -635,7 +635,7 @@ def predict(
         "specifying, the command will not complete until the deployment is complete."
     ),
 )
-# @error_handling
+@error_handling
 def push(
     target_directory: str,
     remote: str,
@@ -670,6 +670,16 @@ def push(
         tr.spec.config.model_name = model_name
         tr.spec.config.write_to_yaml_file(tr.spec.config_path, verbose=False)
 
+    # Log a warning if using secrets without --trusted.
+    # TODO(helen): this could be moved to a separate function that includes more
+    #  config checks.
+    if tr.spec.config.secrets and not trusted:
+        not_trusted_text = (
+            "Warning: your Truss has secrets but was not pushed with --trusted. "
+            "Please push with --trusted to grant access to secrets."
+        )
+        console.print(not_trusted_text, style="red")
+
     # TODO(Abu): This needs to be refactored to be more generic
     service = remote_provider.push(
         tr,
@@ -698,16 +708,6 @@ def push(
 
         click.echo(draft_model_text)
 
-    # Log a warning if using secrets without --trusted.
-    # TODO(helen): this could be moved to a separate function that includes more
-    #  config checks.
-    if tr.spec.config.secrets and not trusted:
-        not_trusted_text = (
-            "Warning: your Truss has secrets but was not pushed with --trusted."
-            "Please push with --trusted to grant access to secrets."
-        )
-        console.print(not_trusted_text, style="red")
-
     if promote:
         promotion_text = (
             "Your Truss has been deployed as a production model. After it successfully "

{truss-0.9.12.dev2 → truss-0.9.13}/truss/config/trt_llm.py

@@ -29,7 +29,7 @@ class TrussTRTLLMQuantizationType(str, Enum):
 class TrussTRTLLMPluginConfiguration(BaseModel):
     multi_block_mode: bool = False
     paged_kv_cache: bool = True
-    use_fused_mlp: bool = False
+    gemm_plugin: str = "float16"
 
 
 class CheckpointSource(Enum):

{truss-0.9.12.dev2 → truss-0.9.13}/truss/constants.py

@@ -2,6 +2,8 @@ import os
 import pathlib
 from typing import Set
 
+USE_BRITON = os.environ.get("USE_BRITON_FOR_TRTLLM", False)
+
 SKLEARN = "sklearn"
 TENSORFLOW = "tensorflow"
 KERAS = "keras"
@@ -17,7 +19,11 @@ CODE_DIR = pathlib.Path(BASE_DIR, "truss")
 TEMPLATES_DIR = pathlib.Path(CODE_DIR, "templates")
 SERVER_CODE_DIR: pathlib.Path = TEMPLATES_DIR / "server"
 TRITON_SERVER_CODE_DIR: pathlib.Path = TEMPLATES_DIR / "triton"
-TRTLLM_TRUSS_DIR: pathlib.Path = TEMPLATES_DIR / "trtllm"
+TRTLLM_BRITON_TRUSS_DIR: pathlib.Path = TEMPLATES_DIR / "trtllm-briton"
+TRTLLM_TRITON_TRUSS_DIR: pathlib.Path = TEMPLATES_DIR / "trtllm"
+TRTLLM_TRUSS_DIR: pathlib.Path = (
+    TRTLLM_BRITON_TRUSS_DIR if USE_BRITON else TRTLLM_TRITON_TRUSS_DIR
+)
 SHARED_SERVING_AND_TRAINING_CODE_DIR_NAME = "shared"
 SHARED_SERVING_AND_TRAINING_CODE_DIR: pathlib.Path = (
     TEMPLATES_DIR / SHARED_SERVING_AND_TRAINING_CODE_DIR_NAME
@@ -99,11 +105,18 @@ HTTP_PUBLIC_BLOB_BACKEND = "http_public"
 REGISTRY_BUILD_SECRET_PREFIX = "DOCKER_REGISTRY_"
 
 TRTLLM_BASE_IMAGE = "baseten/triton_trt_llm:v0.9.0"
+BRITON_TRTLLM_BASE_IMAGE = "baseten/briton-server:v0.0.1"
 TRTLLM_PYTHON_EXECUTABLE = "/usr/bin/python3"
 BASE_TRTLLM_REQUIREMENTS = [
     "tritonclient[all]==2.42.0",
     "transformers==4.40.2",
     "jinja2==3.1.3",
-    "truss==0.9.11",
+    "truss==0.9.12",
+]
+BRITON_BASE_TRTLLM_REQUIREMENTS = [
+    "grpcio==1.64.0",
+    "grpcio-tools==1.64.0",
+    "transformers==4.41.0",
+    "truss==0.9.12",
 ]
 OPENAI_COMPATIBLE_TAG = "openai-compatible"

{truss-0.9.12.dev2 → truss-0.9.13}/truss/contexts/image_builder/serving_image_builder.py

@@ -15,6 +15,8 @@ from huggingface_hub.utils import filter_repo_objects
 from truss.constants import (
     BASE_SERVER_REQUIREMENTS_TXT_FILENAME,
     BASE_TRTLLM_REQUIREMENTS,
+    BRITON_BASE_TRTLLM_REQUIREMENTS,
+    BRITON_TRTLLM_BASE_IMAGE,
     CONTROL_SERVER_CODE_DIR,
     FILENAME_CONSTANTS_MAP,
     MODEL_DOCKERFILE_NAME,
@@ -30,6 +32,7 @@ from truss.constants import (
     TRTLLM_BASE_IMAGE,
     TRTLLM_PYTHON_EXECUTABLE,
     TRTLLM_TRUSS_DIR,
+    USE_BRITON,
     USER_SUPPLIED_REQUIREMENTS_TXT_FILENAME,
 )
 from truss.contexts.image_builder.cache_warmer import (
@@ -351,10 +354,14 @@ class ServingImageBuilder(ImageBuilder):
                 )
 
             config.base_image = BaseImage(
-                image=TRTLLM_BASE_IMAGE,
+                image=BRITON_TRTLLM_BASE_IMAGE if USE_BRITON else TRTLLM_BASE_IMAGE,
                 python_executable_path=TRTLLM_PYTHON_EXECUTABLE,
             )
-            config.requirements.extend(BASE_TRTLLM_REQUIREMENTS)
+            config.requirements.extend(
+                BRITON_BASE_TRTLLM_REQUIREMENTS
+                if USE_BRITON
+                else BASE_TRTLLM_REQUIREMENTS
+            )
 
             config.model_metadata["tags"] = [OPENAI_COMPATIBLE_TAG]
 

{truss-0.9.12.dev2 → truss-0.9.13}/truss/remote/baseten/service.py

@@ -89,7 +89,7 @@ class BasetenService(TrussService):
             # will be a json with an `error` key.
             return parsed_response
 
-        return response.json()["model_output"]
+        return response.json()
 
     def authenticate(self) -> dict:
         return self._auth_service.authenticate().header()

{truss-0.9.12.dev2 → truss-0.9.13}/truss/templates/control/requirements.txt

@@ -1,5 +1,5 @@
 dataclasses-json==0.5.7
-truss==0.9.1rc1
+truss==0.9.12
 fastapi==0.109.1
 uvicorn==0.24.0
 uvloop==0.19.0

truss-0.9.13/truss/templates/trtllm-briton/model/model.py

@@ -0,0 +1,173 @@
+import os
+import signal
+import socket
+import subprocess
+import threading
+import time
+from itertools import count
+
+import briton_pb2
+import briton_pb2_grpc
+import grpc
+from transformers import AutoTokenizer
+from truss.config.trt_llm import TrussTRTLLMBuildConfiguration
+from truss.constants import OPENAI_COMPATIBLE_TAG
+
+BRITON_PORT = 50051
+
+MODEL_INPUT_TO_BRITON_FIELD = {
+    "max_tokens": "request_output_len",
+    "beam_width": "beam_width",
+    "repetition_penalty": "repetition_penalty",
+    "presence_penalty": "presence_penalty",
+    "temperature": "temperature",
+    "length_penalty": "len_penalty",
+    "end_id": "end_id",
+    "pad_id": "pad_id",
+    "runtime_top_k": "runtime_top_k",
+    "runtime_top_p": "runtime_top_p",
+}
+
+
+def is_port_available(port, host="localhost"):
+    try:
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+            # Try to connect to the specified host and port
+            s.bind((host, port))
+            return True
+    except OSError:
+        # Port is not available
+        return False
+
+
+def briton_monitor(briton_process):
+    while True:
+        if briton_process.poll() is not None:
+            print(
+                f"Briton process has exited with code {briton_process.returncode}, exiting truss server"
+            )
+            pid = os.getpid()
+            os.kill(pid, signal.SIGKILL)
+        time.sleep(1)
+
+
+class Model:
+    def __init__(self, **kwargs):
+        self._model = None
+        self._config = kwargs["config"]
+        self._data_dir = kwargs["data_dir"]
+        self._stub = None
+        self._secrets = kwargs["secrets"]
+        self._request_id_counter = count(start=1)
+        self._briton_process = None
+        self._uses_openai_api = OPENAI_COMPATIBLE_TAG in self._config.get(
+            "model_metadata", {}
+        ).get("tags", [])
+
+        if "trt_llm" not in self._config:
+            raise ValueError("trt_llm config is required for this model")
+
+        trtllm_config = self._config.get("trt_llm")
+        truss_trtllm_build_config = TrussTRTLLMBuildConfiguration(
+            **trtllm_config.get("build")
+        )
+        self._tp_count = truss_trtllm_build_config.tensor_parallel_count
+        self._tokenizer_repository = (
+            truss_trtllm_build_config.checkpoint_repository.repo
+        )
+
+        self._hf_token = None
+        try:
+            self._hf_token = self._secrets.get("hf_access_token", None)
+        except:  # noqa
+            pass
+
+    def load(self):
+        self._tokenizer = AutoTokenizer.from_pretrained(
+            self._tokenizer_repository, token=self._hf_token
+        )
+        # Start engine
+        config_str = f'engine_path: "{self._data_dir.resolve()}"\nhf_tokenizer: "{self._tokenizer_repository}"'
+        config_pbtxt_path = (self._data_dir / "briton_config.pbtxt").resolve()
+        config_pbtxt_path.write_text(config_str)
+        briton_env = os.environ.copy()
+        if self._hf_token is not None:
+            briton_env["HF_ACCESS_TOKEN"] = self._hf_token
+        if self._tp_count is None or self._tp_count == 1:
+            self._briton_process = subprocess.Popen(
+                ["Briton", "--config", str(config_pbtxt_path)], env=briton_env
+            )
+        else:
+            self._briton_process = subprocess.Popen(
+                [
+                    "mpirun",
+                    "--allow-run-as-root",
+                    "-n",
+                    f"{self._tp_count}",
+                    "Briton",
+                    "--config",
+                    str(config_pbtxt_path),
+                ],
+                env=briton_env,
+            )
+        while is_port_available(BRITON_PORT):
+            print("Waiting for Briton to start")
+            time.sleep(1)
+
+        briton_monitor_thread = threading.Thread(
+            target=briton_monitor, args=(self._briton_process,)
+        )
+        briton_monitor_thread.start()
+
+    async def predict(self, model_input):
+        if self._stub is None:
+            channel = grpc.aio.insecure_channel(f"localhost:{BRITON_PORT}")
+            self._stub = briton_pb2_grpc.BritonStub(channel)
+
+        prompt = model_input.get("prompt", None)
+        if prompt is None and "messages" in model_input:
+            messages = model_input.pop("messages")
+            if self._uses_openai_api:
+                prompt = self._tokenizer.apply_chat_template(messages, tokenize=False)
+
+        if prompt is None or prompt == "":
+            yield ""
+            return
+        request_id = int(str(os.getpid()) + str(next(self._request_id_counter)))
+        request = briton_pb2.InferenceRequest(
+            request_id=request_id,
+            input_text=prompt,
+        )
+        # Set default end_id and pad_id
+        if (
+            hasattr(self._tokenizer, "eos_token_id")
+            and self._tokenizer.eos_token_id is not None
+        ):
+            request.end_id = self._tokenizer.eos_token_id
+        if (
+            hasattr(self._tokenizer, "pad_token_id")
+            and self._tokenizer.pad_token_id is not None
+        ):
+            request.pad_id = self._tokenizer.pad_token_id
+        set_briton_request_fields_from_model_input(model_input, request)
+        for words in ["bad_words", "stop_words"]:
+            if words in model_input:
+                for word in model_input[words].split(","):
+                    getattr(request, words).append(word)
+
+        try:
+            async for response in self._stub.Infer(request):
+                yield response.output_text
+        except grpc.RpcError as ex:
+            if ex.code() == grpc.StatusCode.INVALID_ARGUMENT:
+                print(ex.details())
+        except Exception as ex:
+            print(f"An error has occurred: {ex}")
+            raise ex
+
+
+def set_briton_request_fields_from_model_input(model_input, briton_request):
+    for model_input_key, briton_field in MODEL_INPUT_TO_BRITON_FIELD.items():
+        if model_input_key in model_input:
+            model_input_value = model_input[model_input_key]
+            setattr(briton_request, briton_field, model_input_value)

truss-0.9.13/truss/templates/trtllm-briton/packages/briton_pb2.py

@@ -0,0 +1,38 @@
+# flake8: noqa
+# type: ignore
+
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: briton.proto
+# Protobuf Python Version: 5.26.1
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(
+    b'\n\x0c\x62riton.proto\x12\x06\x62riton"\xb0\x04\n\x10InferenceRequest\x12\x12\n\nrequest_id\x18\x01 \x01(\x03\x12\x12\n\ninput_text\x18\x02 \x01(\t\x12\x11\n\tinput_ids\x18\x03 \x03(\x05\x12\x1f\n\x12request_output_len\x18\x05 \x01(\rH\x00\x88\x01\x01\x12\x13\n\x06\x65nd_id\x18\x06 \x01(\rH\x01\x88\x01\x01\x12\x13\n\x06pad_id\x18\x07 \x01(\rH\x02\x88\x01\x01\x12\x17\n\nbeam_width\x18\n \x01(\rH\x03\x88\x01\x01\x12\x18\n\x0btemperature\x18\x0b \x01(\x02H\x04\x88\x01\x01\x12\x1a\n\rruntime_top_k\x18\x0c \x01(\rH\x05\x88\x01\x01\x12\x1a\n\rruntime_top_p\x18\r \x01(\x02H\x06\x88\x01\x01\x12\x18\n\x0blen_penalty\x18\x0e \x01(\x02H\x07\x88\x01\x01\x12\x1f\n\x12repetition_penalty\x18\x0f \x01(\x02H\x08\x88\x01\x01\x12\x1d\n\x10presence_penalty\x18\x10 \x01(\x02H\t\x88\x01\x01\x12\x11\n\tbad_words\x18\x11 \x03(\t\x12\x12\n\nstop_words\x18\x12 \x03(\tB\x15\n\x13_request_output_lenB\t\n\x07_end_idB\t\n\x07_pad_idB\r\n\x0b_beam_widthB\x0e\n\x0c_temperatureB\x10\n\x0e_runtime_top_kB\x10\n\x0e_runtime_top_pB\x0e\n\x0c_len_penaltyB\x15\n\x13_repetition_penaltyB\x13\n\x11_presence_penalty"R\n\x13InferenceAnswerPart\x12\x12\n\nrequest_id\x18\x01 \x01(\x03\x12\x13\n\x0boutput_text\x18\x02 \x01(\t\x12\x12\n\noutput_ids\x18\x03 \x03(\x05"\xfa\x03\n\x0c\x42ritonConfig\x12\x13\n\x0b\x65ngine_path\x18\x01 \x01(\t\x12\x14\n\x0chf_tokenizer\x18\x02 \x01(\t\x12N\n\x16\x62\x61tch_scheduler_policy\x18\x05 \x01(\x0e\x32).briton.BritonConfig.BatchSchedulerPolicyH\x00\x88\x01\x01\x12\x1f\n\x12\x65nable_trt_overlap\x18\x06 \x01(\x08H\x01\x88\x01\x01\x12)\n\x1cmax_tokens_in_paged_kv_cache\x18\n \x01(\x04H\x02\x88\x01\x01\x12+\n\x1ekv_cache_free_gpu_mem_fraction\x18\x0b \x01(\x02H\x03\x88\x01\x01\x12!\n\x14medusa_decoding_mode\x18\x0c \x01(\x08H\x04\x88\x01\x01"D\n\x14\x42\x61tchSchedulerPolicy\x12\x13\n\x0fMAX_UTILIZATION\x10\x00\x12\x17\n\x13GUARANTEED_NO_EVICT\x10\x01\x42\x19\n\x17_batch_scheduler_policyB\x15\n\x13_enable_trt_overlapB\x1f\n\x1d_max_tokens_in_paged_kv_cacheB!\n\x1f_kv_cache_free_gpu_mem_fractionB\x17\n\x15_medusa_decoding_mode2L\n\x06\x42riton\x12\x42\n\x05Infer\x12\x18.briton.InferenceRequest\x1a\x1b.briton.InferenceAnswerPart"\x00\x30\x01\x62\x06proto3'
+)
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, "briton_pb2", _globals)
+if not _descriptor._USE_C_DESCRIPTORS:
+    DESCRIPTOR._loaded_options = None
+    _globals["_INFERENCEREQUEST"]._serialized_start = 25
+    _globals["_INFERENCEREQUEST"]._serialized_end = 585
+    _globals["_INFERENCEANSWERPART"]._serialized_start = 587
+    _globals["_INFERENCEANSWERPART"]._serialized_end = 669
+    _globals["_BRITONCONFIG"]._serialized_start = 672
+    _globals["_BRITONCONFIG"]._serialized_end = 1178
+    _globals["_BRITONCONFIG_BATCHSCHEDULERPOLICY"]._serialized_start = 967
+    _globals["_BRITONCONFIG_BATCHSCHEDULERPOLICY"]._serialized_end = 1035
+    _globals["_BRITON"]._serialized_start = 1180
+    _globals["_BRITON"]._serialized_end = 1256
+# @@protoc_insertion_point(module_scope)

truss-0.9.13/truss/templates/trtllm-briton/packages/briton_pb2_grpc.py

@@ -0,0 +1,112 @@
+# flake8: noqa
+# type: ignore
+
+# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
+"""Client and server classes corresponding to protobuf-defined services."""
+import warnings
+
+import briton_pb2 as briton__pb2
+import grpc
+
+GRPC_GENERATED_VERSION = "1.63.0"
+GRPC_VERSION = grpc.__version__
+EXPECTED_ERROR_RELEASE = "1.65.0"
+SCHEDULED_RELEASE_DATE = "June 25, 2024"
+_version_not_supported = False
+
+try:
+    from grpc._utilities import first_version_is_lower
+
+    _version_not_supported = first_version_is_lower(
+        GRPC_VERSION, GRPC_GENERATED_VERSION
+    )
+except ImportError:
+    _version_not_supported = True
+
+if _version_not_supported:
+    warnings.warn(
+        f"The grpc package installed is at version {GRPC_VERSION},"
+        + f" but the generated code in briton_pb2_grpc.py depends on"
+        + f" grpcio>={GRPC_GENERATED_VERSION}."
+        + f" Please upgrade your grpc module to grpcio>={GRPC_GENERATED_VERSION}"
+        + f" or downgrade your generated code using grpcio-tools<={GRPC_VERSION}."
+        + f" This warning will become an error in {EXPECTED_ERROR_RELEASE},"
+        + f" scheduled for release on {SCHEDULED_RELEASE_DATE}.",
+        RuntimeWarning,
+    )
+
+
+class BritonStub(object):
+    """The greeting service definition."""
+
+    def __init__(self, channel):
+        """Constructor.
+
+        Args:
+            channel: A grpc.Channel.
+        """
+        self.Infer = channel.unary_stream(
+            "/briton.Briton/Infer",
+            request_serializer=briton__pb2.InferenceRequest.SerializeToString,
+            response_deserializer=briton__pb2.InferenceAnswerPart.FromString,
+            _registered_method=True,
+        )
+
+
+class BritonServicer(object):
+    """The greeting service definition."""
+
+    def Infer(self, request, context):
+        """Sends a greeting"""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details("Method not implemented!")
+        raise NotImplementedError("Method not implemented!")
+
+
+def add_BritonServicer_to_server(servicer, server):
+    rpc_method_handlers = {
+        "Infer": grpc.unary_stream_rpc_method_handler(
+            servicer.Infer,
+            request_deserializer=briton__pb2.InferenceRequest.FromString,
+            response_serializer=briton__pb2.InferenceAnswerPart.SerializeToString,
+        ),
+    }
+    generic_handler = grpc.method_handlers_generic_handler(
+        "briton.Briton", rpc_method_handlers
+    )
+    server.add_generic_rpc_handlers((generic_handler,))
+
+
+# This class is part of an EXPERIMENTAL API.
+class Briton(object):
+    """The greeting service definition."""
+
+    @staticmethod
+    def Infer(
+        request,
+        target,
+        options=(),
+        channel_credentials=None,
+        call_credentials=None,
+        insecure=False,
+        compression=None,
+        wait_for_ready=None,
+        timeout=None,
+        metadata=None,
+    ):
+        return grpc.experimental.unary_stream(
+            request,
+            target,
+            "/briton.Briton/Infer",
+            briton__pb2.InferenceRequest.SerializeToString,
+            briton__pb2.InferenceAnswerPart.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True,
+        )

{truss-0.9.12.dev2 → truss-0.9.13}/truss/test_data/test_basic_truss/config.yaml

@@ -9,5 +9,7 @@ resources:
   cpu: '1'
   memory: 2Gi
   use_gpu: false
-secrets: {}
+secrets:
+  foo: "foo"
+  bar: "bar"
 system_packages: []

{truss-0.9.12.dev2 → truss-0.9.13}/truss/tests/test_config.py

@@ -315,29 +315,57 @@ def test_empty_config():
 
 
 def test_from_yaml():
-    yaml_path = Path("test.yaml")
     data = {"description": "this is a test"}
-    with yaml_path.open("w") as yaml_file:
+    with tempfile.NamedTemporaryFile(mode="w", delete=False) as yaml_file:
+        yaml_path = Path(yaml_file.name)
         yaml.safe_dump(data, yaml_file)
 
-    result = TrussConfig.from_yaml(yaml_path)
-
-    assert result.description == "this is a test"
+        result = TrussConfig.from_yaml(yaml_path)
 
-    yaml_path.unlink()
+        assert result.description == "this is a test"
 
 
 def test_from_yaml_empty():
-    yaml_path = Path("test.yaml")
     data = {}
-    with yaml_path.open("w") as yaml_file:
+    with tempfile.NamedTemporaryFile(mode="w", delete=False) as yaml_file:
+        yaml_path = Path(yaml_file.name)
         yaml.safe_dump(data, yaml_file)
 
-    result = TrussConfig.from_yaml(yaml_path)
+        result = TrussConfig.from_yaml(yaml_path)
+
+        # test some attributes (should be default)
+        assert result.description is None
+        assert result.spec_version == "2.0"
+        assert result.bundled_packages_dir == "packages"
+
+
+def test_from_yaml_secrets_as_list():
+    data = {"description": "this is a test", "secrets": ["foo", "bar"]}
+    with tempfile.NamedTemporaryFile(mode="w", delete=False) as yaml_file:
+        yaml_path = Path(yaml_file.name)
+        yaml.safe_dump(data, yaml_file)
+
+        with pytest.raises(ValueError):
+            TrussConfig.from_yaml(yaml_path)
+
+
+def test_from_yaml_python_version():
+    yaml_path = Path("test.yaml")
+    invalid_py_version_data = {
+        "description": "this is a test",
+        "python_version": "py38",
+    }
+    with tempfile.NamedTemporaryFile(mode="w", delete=False) as yaml_file:
+        yaml_path = Path(yaml_file.name)
+        yaml.safe_dump(invalid_py_version_data, yaml_file)
+
+        with pytest.raises(ValueError):
+            TrussConfig.from_yaml(yaml_path)
 
-    # test some attributes (should be default)
-    assert result.description is None
-    assert result.spec_version == "2.0"
-    assert result.bundled_packages_dir == "packages"
+    valid_py_version_data = {"description": "this is a test", "python_version": "py39"}
+    with tempfile.NamedTemporaryFile(mode="w", delete=False) as yaml_file:
+        yaml_path = Path(yaml_file.name)
+        yaml.safe_dump(valid_py_version_data, yaml_file)
 
-    yaml_path.unlink()
+        result = TrussConfig.from_yaml(yaml_path)
+        result.python_version == "py39"

{truss-0.9.12.dev2 → truss-0.9.13}/truss/truss_config.py

@@ -39,6 +39,8 @@ DEFAULT_USE_GPU = False
 
 DEFAULT_BLOB_BACKEND = HTTP_PUBLIC_BLOB_BACKEND
 
+VALID_PYTHON_VERSIONS = ["py39", "py310", "py311"]
+
 # Set up logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
@@ -576,6 +578,21 @@ class TrussConfig:
         return TrussConfig.from_dict(self.to_dict())
 
     def validate(self):
+        if self.python_version not in VALID_PYTHON_VERSIONS:
+
+            raise ValueError(
+                f"Please ensure that `python_version` is one of {VALID_PYTHON_VERSIONS}"
+            )
+
+        if not isinstance(self.secrets, dict):
+            raise ValueError(
+                "Please ensure that `secrets` is a mapping of the form:\n"
+                "```\n"
+                "secrets:\n"
+                '  secret1: "some default value"\n'
+                '  secret2: "some other default value"\n'
+                "```"
+            )
         for secret_name in self.secrets:
             validate_secret_name(secret_name)
 

{truss-0.9.12.dev2 → truss-0.9.13}/truss/validation.py

@@ -1,5 +1,5 @@
 import re
-from pathlib import Path
+from pathlib import PosixPath
 from typing import Pattern, Set
 
 from truss.constants import REGISTRY_BUILD_SECRET_PREFIX
@@ -81,9 +81,10 @@ def _is_numeric(number_like: str) -> bool:
 def validate_python_executable_path(path: str) -> None:
     """
     This python executable path determines the python executable
-    used to run the inference server - check to see that it is an absolute path
+    used to run the inference server - check to see that it is an absolute path.
+    We use PosixPath -- TrussServer always runs on a Posix machine.
     """
-    if path and not Path(path).is_absolute():
+    if path and not PosixPath(path).is_absolute():
         raise ValidationError(
             f"Invalid relative python executable path {path}. Provide an absolute path"
         )

{truss-0.9.12.dev2 → truss-0.9.13}/truss-chains/truss_chains/__init__.py

@@ -23,10 +23,10 @@ from truss_chains.definitions import (
 )
 from truss_chains.public_api import (
     ChainletBase,
+    depends,
+    depends_context,
     deploy_remotely,
     entrypoint,
-    provide,
-    provide_context,
     run_local,
 )
 from truss_chains.stub import StubBase