truss 0.9.45.dev101__tar.gz → 0.9.45rc9__tar.gz

{truss-0.9.45.dev101 → truss-0.9.45rc9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: truss
-Version: 0.9.45.dev101
+Version: 0.9.45rc9
 Summary: A seamless bridge from model development to model delivery
 Home-page: https://github.com/basetenlabs/truss
 License: MIT
@@ -17,7 +17,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Requires-Dist: Jinja2 (>=3.1.2,<4.0.0)
 Requires-Dist: PyYAML (>=6.0)
-Requires-Dist: aiohttp (>=3.10.10,<4.0.0)
+Requires-Dist: aiofiles (>=24.1.0,<25.0.0)
 Requires-Dist: blake3 (>=0.3.3,<0.4.0)
 Requires-Dist: boto3 (>=1.34.85,<2.0.0)
 Requires-Dist: fastapi (>=0.109.1)

{truss-0.9.45.dev101 → truss-0.9.45rc9}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "truss"
-version = "0.9.45dev101"
+version = "0.9.45rc009"
 description = "A seamless bridge from model development to model delivery"
 license = "MIT"
 readme = "README.md"
@@ -27,7 +27,7 @@ packages = [
 "Baseten" = "https://baseten.co"
 
 [tool.poetry.dependencies]
-aiohttp = "^3.10.10"
+aiofiles = "^24.1.0"
 blake3 = "^0.3.3"
 boto3 = "^1.34.85"
 fastapi = ">=0.109.1"
@@ -97,6 +97,7 @@ pytest = "7.2.0"
 pytest-cov = "^3.0.0"
 types-PyYAML = "^6.0.12.12"
 types-setuptools = "^69.0.0.0"
+types-aiofiles = "^24.1.0.20240626"
 
 [tool.poetry.scripts]
 truss = 'truss.cli:truss_cli'

{truss-0.9.45.dev101 → truss-0.9.45rc9}/truss/local/local_config_handler.py

@@ -75,6 +75,18 @@ class LocalConfigHandler:
         bptr_data_dir.mkdir(exist_ok=True, parents=True)
         return bptr_data_dir
 
+    @staticmethod
+    def dynamic_config_path():
+        dynamic_config_dir = LocalConfigHandler.TRUSS_CONFIG_DIR / "b10_dynamic_config"
+        dynamic_config_dir.mkdir(exist_ok=True, parents=True)
+        return dynamic_config_dir
+
+    @staticmethod
+    def set_dynamic_config(key: str, value: str):
+        key_path = LocalConfigHandler.dynamic_config_path() / key
+        with key_path.open("w") as key_file:
+            key_file.write(value)
+
     @staticmethod
     def _signatures_dir_path():
         return LocalConfigHandler.TRUSS_CONFIG_DIR / "signatures"

{truss-0.9.45.dev101 → truss-0.9.45rc9}/truss/templates/server/model_wrapper.py

@@ -4,6 +4,7 @@ import enum
 import importlib
 import importlib.util
 import inspect
+import json
 import logging
 import os
 import pathlib
@@ -35,7 +36,7 @@ from common.retry import retry
 from common.schema import TrussSchema
 from opentelemetry import trace
 from pydantic import BaseModel
-from shared import serialization
+from shared import dynamic_config_resolver, serialization
 from shared.lazy_data_resolver import LazyDataResolver
 from shared.secrets_resolver import SecretsResolver
 
@@ -53,6 +54,7 @@ EXTENSIONS_DIR_NAME = "extensions"
 EXTENSION_CLASS_NAME = "Extension"
 EXTENSION_FILE_NAME = "extension"
 TRT_LLM_EXTENSION_NAME = "trt_llm"
+POLL_FOR_ENVIRONMENT_UPDATES_TIMEOUT_SECS = 30
 
 
 @asynccontextmanager
@@ -191,6 +193,7 @@ class ModelDescriptor:
     predict: MethodDescriptor
     postprocess: Optional[MethodDescriptor]
     truss_schema: Optional[TrussSchema]
+    setup_environment: Optional[MethodDescriptor]
 
     @cached_property
     def skip_input_parsing(self) -> bool:
@@ -243,11 +246,19 @@ class ModelDescriptor:
         else:
             return_annotation = inspect.signature(model.predict).return_annotation
 
+        if hasattr(model, "setup_environment"):
+            setup_environment = MethodDescriptor.from_method(
+                model.setup_environment, "setup_environment"
+            )
+        else:
+            setup_environment = None
+
         return cls(
             preprocess=preprocess,
             predict=predict,
             postprocess=postprocess,
             truss_schema=TrussSchema.from_signature(parameters, return_annotation),
+            setup_environment=setup_environment,
         )
 
 
@@ -259,6 +270,8 @@ class ModelWrapper:
     _logger: logging.Logger
     _status: "ModelWrapper.Status"
     _predict_semaphore: Semaphore
+    _poll_for_environment_updates_task: Optional[asyncio.Task]
+    _environment: Optional[dict]
 
     class Status(Enum):
         NOT_READY = 0
@@ -280,6 +293,8 @@ class ModelWrapper:
                 "predict_concurrency", DEFAULT_PREDICT_CONCURRENCY
             )
         )
+        self._poll_for_environment_updates_task = None
+        self._environment = None
 
     @property
     def _model(self) -> Any:
@@ -419,6 +434,9 @@ class ModelWrapper:
 
         self._maybe_model_descriptor = ModelDescriptor.from_model(self._model)
 
+        if self._maybe_model_descriptor.setup_environment:
+            self._initialize_environment_before_load()
+
         if hasattr(self._model, "load"):
             retry(
                 self._model.load,
@@ -428,6 +446,76 @@ class ModelWrapper:
                 gap_seconds=1.0,
             )
 
+    def setup_polling_for_environment_updates(self):
+        self._poll_for_environment_updates_task = asyncio.create_task(
+            self.poll_for_environment_updates()
+        )
+
+    def _initialize_environment_before_load(self):
+        environment_str = dynamic_config_resolver.get_dynamic_config_value_sync(
+            dynamic_config_resolver.ENVIRONMENT_DYNAMIC_CONFIG_KEY
+        )
+        if environment_str:
+            environment_json = json.loads(environment_str)
+            self._logger.info(
+                f"Executing model.setup_environment with environment: {environment_json}"
+            )
+            # TODO: Support calling an async setup_environment() here once we support async load()
+            self._model.setup_environment(environment_json)
+            self._environment = environment_json
+
+    async def setup_environment(self, environment: Optional[dict]):
+        descriptor = self.model_descriptor.setup_environment
+        if not descriptor:
+            return
+        self._logger.info(
+            f"Executing model.setup_environment with new environment: {environment}"
+        )
+        if descriptor.is_async:
+            return await self._model.setup_environment(environment)
+        else:
+            return await to_thread.run_sync(self._model.setup_environment, environment)
+
+    async def poll_for_environment_updates(self) -> None:
+        last_modified_time = None
+        environment_config_filename = (
+            dynamic_config_resolver.get_dynamic_config_file_path(
+                dynamic_config_resolver.ENVIRONMENT_DYNAMIC_CONFIG_KEY
+            )
+        )
+
+        while True:
+            # Give control back to the event loop while waiting for environment updates
+            await asyncio.sleep(POLL_FOR_ENVIRONMENT_UPDATES_TIMEOUT_SECS)
+
+            # Wait for load to finish before checking for environment updates
+            if not self.ready:
+                continue
+
+            # Skip polling if no setup_environment implementation provided
+            if not self.model_descriptor.setup_environment:
+                break
+
+            if environment_config_filename.exists():
+                try:
+                    current_mtime = os.path.getmtime(environment_config_filename)
+                    if not last_modified_time or last_modified_time != current_mtime:
+                        environment_str = await dynamic_config_resolver.get_dynamic_config_value_async(
+                            dynamic_config_resolver.ENVIRONMENT_DYNAMIC_CONFIG_KEY
+                        )
+                        if environment_str:
+                            last_modified_time = current_mtime
+                            environment_json = json.loads(environment_str)
+                            # Avoid rerunning `setup_environment` with the same environment
+                            if self._environment != environment_json:
+                                await self.setup_environment(environment_json)
+                                self._environment = environment_json
+                except Exception as e:
+                    self._logger.exception(
+                        "Exception while setting up environment: " + str(e),
+                        exc_info=errors.filter_traceback(self._model_file_name),
+                    )
+
     async def preprocess(
         self,
         inputs: serialization.InputType,

{truss-0.9.45.dev101 → truss-0.9.45rc9}/truss/templates/server/requirements.txt

@@ -17,3 +17,4 @@ pyyaml==6.0.0
 requests==2.31.0
 uvicorn==0.24.0
 uvloop==0.19.0
+aiofiles==24.1.0

{truss-0.9.45.dev101 → truss-0.9.45rc9}/truss/templates/server/truss_server.py

@@ -281,6 +281,7 @@ class TrussServer:
         if self._setup_json_logger:
             setup_logging()
         self._model.start_load_thread()
+        self._model.setup_polling_for_environment_updates()
 
     def create_application(self):
         app = FastAPI(

truss-0.9.45rc9/truss/templates/shared/dynamic_config_resolver.py

@@ -0,0 +1,28 @@
+from pathlib import Path
+from typing import Optional
+
+import aiofiles
+
+DYNAMIC_CONFIG_MOUNT_DIR = "/etc/b10_dynamic_config"
+ENVIRONMENT_DYNAMIC_CONFIG_KEY = "environment"
+
+
+def get_dynamic_config_value_sync(key: str) -> Optional[str]:
+    dynamic_config_path = Path(DYNAMIC_CONFIG_MOUNT_DIR) / key
+    if dynamic_config_path.exists():
+        with dynamic_config_path.open() as dynamic_config_file:
+            return dynamic_config_file.read()
+    return None
+
+
+def get_dynamic_config_file_path(key: str):
+    dynamic_config_path = Path(DYNAMIC_CONFIG_MOUNT_DIR) / key
+    return dynamic_config_path
+
+
+async def get_dynamic_config_value_async(key: str) -> Optional[str]:
+    dynamic_config_path = get_dynamic_config_file_path(key)
+    if dynamic_config_path.exists():
+        async with aiofiles.open(dynamic_config_path, "r") as dynamic_config_file:
+            return await dynamic_config_file.read()
+    return None

truss-0.9.45rc9/truss/test_data/model_load_failure_test/config.yaml

@@ -0,0 +1,2 @@
+model_name: Test Load Failure
+python_version: py39

truss-0.9.45rc9/truss/tests/templates/core/server/test_dynamic_config_resolver.py

@@ -0,0 +1,126 @@
+import json
+
+import aiofiles
+import pytest
+from truss.templates.shared import dynamic_config_resolver
+
+from truss_chains import definitions
+
+
+@pytest.mark.parametrize(
+    "config",
+    [
+        {
+            "RandInt": {
+                "predict_url": "https://model-id.api.baseten.co/deployment/deployment-id/predict"
+            }
+        },
+        {},
+        "",
+    ],
+)
+def test_get_dynamic_chainlet_config_value_sync(
+    config, tmp_path, dynamic_config_mount_dir
+):
+    with (tmp_path / definitions.DYNAMIC_CHAINLET_CONFIG_KEY).open("w") as f:
+        f.write(json.dumps(config))
+    chainlet_service_config = dynamic_config_resolver.get_dynamic_config_value_sync(
+        definitions.DYNAMIC_CHAINLET_CONFIG_KEY
+    )
+    assert json.loads(chainlet_service_config) == config
+
+
+@pytest.mark.parametrize(
+    "config",
+    [
+        {
+            "environment_name": "production",
+            "foo": "bar",
+        },
+        {},
+        "",
+        None,
+    ],
+)
+def test_get_dynamic_config_environment_value_sync(
+    config, tmp_path, dynamic_config_mount_dir
+):
+    with (tmp_path / dynamic_config_resolver.ENVIRONMENT_DYNAMIC_CONFIG_KEY).open(
+        "w"
+    ) as f:
+        f.write(json.dumps(config))
+    environment_str = dynamic_config_resolver.get_dynamic_config_value_sync(
+        dynamic_config_resolver.ENVIRONMENT_DYNAMIC_CONFIG_KEY
+    )
+    assert json.loads(environment_str) == config
+
+
+def test_get_missing_config_value_sync(dynamic_config_mount_dir):
+    chainlet_service_config = dynamic_config_resolver.get_dynamic_config_value_sync(
+        definitions.DYNAMIC_CHAINLET_CONFIG_KEY
+    )
+    assert not chainlet_service_config
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "config",
+    [
+        {
+            "RandInt": {
+                "predict_url": "https://model-id.api.baseten.co/deployment/deployment-id/predict"
+            }
+        },
+        {},
+        "",
+    ],
+)
+async def test_get_dynamic_chainlet_config_value_async(
+    config, tmp_path, dynamic_config_mount_dir
+):
+    async with aiofiles.open(
+        tmp_path / definitions.DYNAMIC_CHAINLET_CONFIG_KEY, "w"
+    ) as f:
+        await f.write(json.dumps(config))
+    chainlet_service_config = (
+        await dynamic_config_resolver.get_dynamic_config_value_async(
+            definitions.DYNAMIC_CHAINLET_CONFIG_KEY
+        )
+    )
+    assert json.loads(chainlet_service_config) == config
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "config",
+    [
+        {
+            "environment_name": "production",
+            "foo": "bar",
+        },
+        {},
+        "",
+        None,
+    ],
+)
+async def test_get_dynamic_config_environment_value_async(
+    config, tmp_path, dynamic_config_mount_dir
+):
+    async with aiofiles.open(
+        tmp_path / dynamic_config_resolver.ENVIRONMENT_DYNAMIC_CONFIG_KEY, "w"
+    ) as f:
+        await f.write(json.dumps(config))
+    environment_str = await dynamic_config_resolver.get_dynamic_config_value_async(
+        dynamic_config_resolver.ENVIRONMENT_DYNAMIC_CONFIG_KEY
+    )
+    assert json.loads(environment_str) == config
+
+
+@pytest.mark.asyncio
+async def test_get_missing_config_value_async(dynamic_config_mount_dir):
+    chainlet_service_config = (
+        await dynamic_config_resolver.get_dynamic_config_value_async(
+            definitions.DYNAMIC_CHAINLET_CONFIG_KEY
+        )
+    )
+    assert not chainlet_service_config

{truss-0.9.45.dev101 → truss-0.9.45rc9}/truss/tests/test_model_inference.py

@@ -760,6 +760,119 @@ def test_slow_truss():
         _test_invocations(200)
 
 
+@pytest.mark.integration
+def test_setup_environment():
+    # Test truss that uses setup_environment() without load()
+    model = """
+    from typing import Optional
+    class Model:
+        def setup_environment(self, environment: Optional[dict]):
+            print("setup_environment called with", environment)
+            self.environment_name = environment.get("name") if environment else None
+            print(f"in {self.environment_name} environment")
+
+        def predict(self, model_input):
+            return model_input
+    """
+    config = "model_name: setup-environment-truss"
+    with ensure_kill_all(), temp_truss(model, config) as tr:
+        container = tr.docker_run(
+            local_port=8090,
+            detach=True,
+            wait_for_server_ready=True,
+        )
+        # Mimic environment changing to beta
+        beta_env = {"name": "beta"}
+        beta_env_str = json.dumps(beta_env)
+        container.execute(
+            [
+                "bash",
+                "-c",
+                f"echo '{beta_env_str}' > /etc/b10_dynamic_config/environment",
+            ]
+        )
+        time.sleep(30)
+        single_quote_beta_env_str = beta_env_str.replace('"', "'")
+        assert (
+            f"Executing model.setup_environment with environment: {single_quote_beta_env_str}"
+            in container.logs()
+        )
+        assert (
+            f"setup_environment called with {single_quote_beta_env_str}"
+            in container.logs()
+        )
+        assert "in beta environment" in container.logs()
+        container.execute(
+            [
+                "bash",
+                "-c",
+                "rm -f /etc/b10_dynamic_config/environment",
+            ]
+        )
+
+    # Test a truss that uses the environment in load()
+    model = """
+    from typing import Optional
+    class Model:
+        def setup_environment(self, environment: Optional[dict]):
+            print("setup_environment called with", environment)
+            self.environment_name = environment.get("name") if environment else None
+            print(f"in {self.environment_name} environment")
+
+        def load(self):
+            print("loading in environment", self.environment_name)
+
+        def predict(self, model_input):
+            return model_input
+    """
+    config = "model_name: setup-environment-and-load-truss"
+    with ensure_kill_all(), temp_truss(model, config) as tr:
+        # Mimic environment changing to staging
+        staging_env = {"name": "staging"}
+        staging_env_str = json.dumps(staging_env)
+        LocalConfigHandler.set_dynamic_config("environment", staging_env_str)
+        container = tr.docker_run(
+            local_port=8090,
+            detach=True,
+            wait_for_server_ready=True,
+        )
+        # Don't need to wait here because we explicitly grab the environment from dynamic_config_resolver before calling user's load()
+        single_quote_staging_env_str = staging_env_str.replace('"', "'")
+        assert (
+            f"Executing model.setup_environment with environment: {single_quote_staging_env_str}"
+            in container.logs()
+        )
+        assert (
+            f"setup_environment called with {single_quote_staging_env_str}"
+            in container.logs()
+        )
+        assert "in staging environment" in container.logs()
+        assert "loading in environment staging" in container.logs()
+        # Set environment to None
+        no_env = None
+        no_env_str = json.dumps(no_env)
+        container.execute(
+            [
+                "bash",
+                "-c",
+                f"echo '{no_env_str}' > /etc/b10_dynamic_config/environment",
+            ]
+        )
+        time.sleep(30)
+        assert (
+            f"Executing model.setup_environment with new environment: {no_env}"
+            in container.logs()
+        )
+        assert "setup_environment called with None" in container.logs()
+        container.execute(
+            [
+                "bash",
+                "-c",
+                "rm -f /etc/b10_dynamic_config/environment",
+            ]
+        )
+
+
 # Tracing ##############################################################################
 
 

{truss-0.9.45.dev101 → truss-0.9.45rc9}/truss/truss_handle.py

@@ -298,6 +298,12 @@ class TrussHandle:
                             f"src={str(LocalConfigHandler.bptr_data_resolution_dir_path())}",
                             "target=/bptr",
                         ],
+                        [
+                            "type=bind",
+                            f"src={str(LocalConfigHandler.dynamic_config_path())}",
+                            "target=/etc/b10_dynamic_config",
+                            "readonly=false",
+                        ],
                     ],
                     gpus=gpus,
                     envs=envs,

{truss-0.9.45.dev101 → truss-0.9.45rc9}/truss-chains/truss_chains/framework.py

@@ -11,6 +11,7 @@ import pathlib
 import pprint
 import sys
 import types
+import warnings
 from typing import (
     Any,
     Callable,
@@ -268,6 +269,25 @@ def _validate_and_describe_endpoint(
         is_async = False
         is_generator = inspect.isgeneratorfunction(endpoint_method)
 
+    if not is_async:
+        warnings.warn(
+            "`run_remote` must be an async (coroutine) function in future releases. "
+            "Replace `def run_remote(...` with `async def run_remote(...`. "
+            "Local testing and execution can be done with  "
+            "`asyncio.run(my_chainlet.run_remote(...))`.\n"
+            "Note on concurrency: previously sync functions were run in threads by the "
+            "Truss server.\bn"
+            "For some frameworks this was **unsafe** (e.g. in torch the CUDA context "
+            "is not thread-safe).\n"
+            "Additionally, python threads hold the GIL and therefore might not give "
+            "actual throughput gains.\n"
+            "To achieve safe and performant concurrency, use framework-specific async "
+            "APIs (e.g. AsyncLLMEngine for vLLM) or generic async batching like such "
+            "as https://github.com/hussein-awala/async-batcher.",
+            DeprecationWarning,
+            stacklevel=1,
+        )
+
     return definitions.EndpointAPIDescriptor(
         input_args=input_args,
         output_types=output_types,

{truss-0.9.45.dev101 → truss-0.9.45rc9}/truss-chains/truss_chains/stub.py

@@ -7,7 +7,6 @@ import time
 from typing import Any, ClassVar, Mapping, Optional, Type, TypeVar, final
 
 import httpx
-import aiohttp
 import tenacity
 
 from truss_chains import definitions, utils
@@ -82,20 +81,17 @@ class BasetenSession:
         assert self._cached_sync_client is not None
         return self._cached_sync_client[0]
 
-    async def _client_async(self) -> aiohttp.ClientSession:
+    async def _client_async(self) -> httpx.AsyncClient:
         # Check `_client_cycle_needed` before and after locking to avoid
         # needing a lock each time the client is accessed.
         if self._client_cycle_needed(self._cached_async_client):
             async with self._async_lock:
                 if self._client_cycle_needed(self._cached_async_client):
-                    connector = aiohttp.TCPConnector(
-                        limit=self._client_limits.max_connections,
-                    )
                     self._cached_async_client = (
-                        aiohttp.ClientSession(
+                        httpx.AsyncClient(
                             headers=self._auth_header,
-                            connector=connector,
-                            timeout=aiohttp.ClientTimeout(total=self._service_descriptor.options.timeout_sec),
+                            timeout=self._service_descriptor.options.timeout_sec,
+                            limits=self._client_limits,
                         ),
                         int(time.time()),
                     )
@@ -142,7 +138,7 @@ class BasetenSession:
                         resp = await client.post(
                             self._service_descriptor.predict_url, json=json_payload
                         )
-                    return await utils.handle_async_response(resp, self.name)
+                    return utils.handle_response(resp, self.name)
                 # As a special case we invalidate the client in case of certificate
                 # errors. This has happened in the past and is a defensive measure.
                 except ssl.SSLError:

{truss-0.9.45.dev101 → truss-0.9.45rc9}/truss-chains/truss_chains/utils.py

@@ -134,7 +134,7 @@ def override_chainlet_to_service_metadata(
     chainlet_to_service: Mapping[str, definitions.ServiceDescriptor],
 ):
     # Override predict_urls in chainlet_to_service ServiceDescriptors if dynamic_chainlet_config exists
-    dynamic_chainlet_config_str = dynamic_config_resolver.get_dynamic_config_value(
+    dynamic_chainlet_config_str = dynamic_config_resolver.get_dynamic_config_value_sync(
         definitions.DYNAMIC_CHAINLET_CONFIG_KEY
     )
     if dynamic_chainlet_config_str:
@@ -309,45 +309,6 @@ def handle_response(response: httpx.Response, remote_name: str) -> Any:
     return response.json()
 
 
-async def handle_async_response(response: httpx.Response, remote_name: str) -> Any:
-    """For successful requests returns JSON, otherwise raises error.
-    """
-    if response.status >= 400:
-        try:
-            response_json = await response.json()
-        except Exception as e:
-            raise ValueError(
-                "Could not get JSON from error response. Status: "
-                f"`{response.status}`."
-            ) from e
-        try:
-            error_json = response_json["error"]
-        except KeyError as e:
-            logging.error(f"response_json: {response_json}")
-            raise ValueError(
-                "Could not get `error` field from JSON from error response"
-            ) from e
-        try:
-            error = definitions.RemoteErrorDetail.model_validate(error_json)
-        except pydantic.ValidationError as e:
-            if isinstance(error_json, str):
-                msg = f"Remote error occurred in `{remote_name}`: '{error_json}'"
-                raise definitions.GenericRemoteException(msg) from None
-            raise ValueError(
-                "Could not parse error. Error details are expected to be either a "
-                "plain string (old truss models) or a serialized "
-                f"`definitions.RemoteErrorDetail.__name__`, got:\n{repr(error_json)}"
-            ) from e
-        exception_cls = _resolve_exception_class(error)
-        msg = (
-            f"(showing remote errors, root message at the bottom)\n"
-            f"--> Preceding Remote Cause:\n"
-            f"{textwrap.indent(error.format(), '    ')}"
-        )
-        raise exception_cls(msg)
-    return await response.json()
-
-
 class InjectedError(Exception):
     """Test error for debugging/dev."""
 

truss-0.9.45.dev101/truss/.pytest_cache/.gitignore

@@ -1,2 +0,0 @@
-# Created by pytest automatically.
-*

truss-0.9.45.dev101/truss/.pytest_cache/CACHEDIR.TAG

@@ -1,4 +0,0 @@
-Signature: 8a477f597d28d172789f06886806bc55
-# This file is a cache directory tag created by pytest.
-# For information about cache directory tags, see:
-#	https://bford.info/cachedir/spec.html

truss-0.9.45.dev101/truss/.pytest_cache/README.md

@@ -1,8 +0,0 @@
-# pytest cache directory #
-
-This directory contains data from the pytest's cache plugin,
-which provides the `--lf` and `--ff` options, as well as the `cache` fixture.
-
-**Do not** commit this to version control.
-
-See [the docs](https://docs.pytest.org/en/stable/how-to/cache.html) for more information.

truss-0.9.45.dev101/truss/.pytest_cache/v/cache/lastfailed

@@ -1 +0,0 @@
-{}