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

truss/contexts/local_loader/truss_module_loader.py

@@ -33,7 +33,7 @@ class TrussModuleFinder(PathFinder):
             truss_modules_path = [cls._truss_dir]
         else:
             truss_modules_path = [
-                str(Path(cls._truss_dir) / cls._bundled_packages_dir_name),
+                str(Path(cls._truss_dir) / cls._bundled_packages_dir_name)
             ]
             if cls._external_packages_dirs:
                 truss_modules_path += [

truss/contexts/local_loader/utils.py

@@ -2,8 +2,8 @@ import copy
 import inspect
 from typing import Dict
 
+from truss.base.truss_spec import TrussSpec
 from truss.local.local_config_handler import LocalConfigHandler
-from truss.truss_spec import TrussSpec
 
 
 def prepare_secrets(spec: TrussSpec) -> Dict[str, str]:

truss/local/local_config.py

@@ -13,8 +13,7 @@ class LocalConfig:
     @staticmethod
     def from_dict(d):
         return LocalConfig(
-            secrets=d.get("secrets", {}),
-            use_sudo=d.get("use_sudo", False),
+            secrets=d.get("secrets", {}), use_sudo=d.get("use_sudo", False)
         )
 
     @staticmethod
@@ -23,10 +22,7 @@ class LocalConfig:
             return LocalConfig.from_dict(yaml.safe_load(yaml_file))
 
     def to_dict(self):
-        return {
-            "secrets": self.secrets,
-            "use_sudo": self.use_sudo,
-        }
+        return {"secrets": self.secrets, "use_sudo": self.use_sudo}
 
     def write_to_yaml_file(self, path: Path):
         with path.open("w") as config_file:

truss/local/local_config_handler.py

@@ -3,8 +3,8 @@ from dataclasses import replace
 from pathlib import Path
 from typing import Optional
 
+from truss.base.validation import validate_secret_name
 from truss.local.local_config import LocalConfig
-from truss.validation import validate_secret_name
 
 
 class LocalConfigHandler:
@@ -44,10 +44,7 @@ class LocalConfigHandler:
         LocalConfigHandler._ensure_config_dir()
         validate_secret_name(secret_name)
         local_config = LocalConfigHandler.get_config()
-        new_secrets = {
-            **local_config.secrets,
-            secret_name: secret_value,
-        }
+        new_secrets = {**local_config.secrets, secret_name: secret_value}
         new_local_config = replace(local_config, secrets=new_secrets)
         new_local_config.write_to_yaml_file(LocalConfigHandler._config_path())
 
@@ -69,6 +66,24 @@ class LocalConfigHandler:
     def secrets_dir_path():
         return LocalConfigHandler.TRUSS_CONFIG_DIR / "secrets"
 
+    @staticmethod
+    def bptr_data_resolution_dir_path():
+        bptr_data_dir = LocalConfigHandler.TRUSS_CONFIG_DIR / "bptr"
+        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/patch/__init__.py

@@ -0,0 +1 @@
+# TODO(marius/TaT): This is a backwards compatibility shim until the baseten context builder is updated.

truss/patch/hash.py

@@ -1,71 +1,5 @@
-from pathlib import Path
-from typing import Any, List, Optional
+from truss.truss_handle.patch.hash import (
+    directory_content_hash,  # TODO(marius/TaT): Remove once backend is updated.import
+)
 
-from blake3 import blake3
-from truss.util.path import get_unignored_relative_paths_from_root
-
-
-def directory_content_hash(
-    root: Path,
-    ignore_patterns: Optional[List[str]] = None,
-) -> str:
-    """Calculate content based hash of a filesystem directory.
-
-    Rough algo: Sort all files by path, then take hash of a content stream, where
-    we write path hash to the stream followed by hash of content if path is a file.
-    Note the hash of hash aspect.
-
-    Also, note that name of the root directory is not taken into account, only the contents
-    underneath. The (root) Directory will have the same hash, even if renamed.
-    """
-    hasher = blake3()
-    paths = list(get_unignored_relative_paths_from_root(root, ignore_patterns))
-    paths.sort()
-    for path in paths:
-        hasher.update(str_hash(str(path)))
-        absolute_path = root / path
-        if absolute_path.is_file():
-            hasher.update(file_content_hash(absolute_path))
-    return hasher.hexdigest()
-
-
-def file_content_hash(file: Path) -> bytes:
-    """Calculate blake3 hash of file content.
-    Returns: binary hash of content
-    """
-    return _file_content_hash_loaded_hasher(file).digest()
-
-
-def file_content_hash_str(file: Path) -> str:
-    """Calculate blake3 hash of file content.
-
-    Returns: string hash of content
-    """
-    return _file_content_hash_loaded_hasher(file).hexdigest()
-
-
-def _file_content_hash_loaded_hasher(file: Path) -> Any:
-    hasher = blake3()
-    buffer = bytearray(128 * 1024)
-    mem_view = memoryview(buffer)
-    with file.open("rb") as f:
-        done = False
-        while not done:
-            n = f.readinto(mem_view)
-            if n > 0:
-                hasher.update(mem_view[:n])
-            else:
-                done = True
-    return hasher
-
-
-def str_hash(content: str) -> bytes:
-    hasher = blake3()
-    hasher.update(content.encode("utf-8"))
-    return hasher.digest()
-
-
-def str_hash_str(content: str) -> str:
-    hasher = blake3()
-    hasher.update(content.encode("utf-8"))
-    return hasher.hexdigest()
+__all__ = ["directory_content_hash"]

truss/patch/signature.py

@@ -1,17 +1,5 @@
-from pathlib import Path
-from typing import List, Optional
+from truss.truss_handle.patch.signature import (
+    calc_truss_signature,  # TODO(marius/TaT): Remove once backend is updated.import
+)
 
-from truss.patch.dir_signature import directory_content_signature
-from truss.patch.types import TrussSignature
-
-
-def calc_truss_signature(
-    truss_dir: Path, ignore_patterns: Optional[List[str]] = None
-) -> TrussSignature:
-    content_signature = directory_content_signature(truss_dir, ignore_patterns)
-    with (truss_dir / "config.yaml").open("r") as config_file:
-        config = config_file.read()
-    return TrussSignature(
-        content_hashes_by_path=content_signature,
-        config=config,
-    )
+__all__ = ["calc_truss_signature"]

truss/patch/truss_dir_patch_applier.py

@@ -1,80 +1,5 @@
-import logging
-from pathlib import Path
-from typing import List
-
-from truss.server.control.errors import UnsupportedPatch
-from truss.server.control.patch.model_code_patch_applier import apply_code_patch
-from truss.server.control.patch.requirement_name_identifier import (
-    identify_requirement_name,
-    reqs_by_name,
-)
-from truss.server.control.patch.system_packages import system_packages_set
-from truss.server.control.patch.types import (
-    Action,
-    ConfigPatch,
-    EnvVarPatch,
-    ExternalDataPatch,
-    ModelCodePatch,
-    Patch,
-    PythonRequirementPatch,
-    SystemPackagePatch,
+from truss.truss_handle.patch.truss_dir_patch_applier import (
+    TrussDirPatchApplier,  # TODO(marius/TaT): Remove once backend is updated.import
 )
-from truss.truss_config import TrussConfig
-
-
-class TrussDirPatchApplier:
-    """Applies patches to a truss directory.
-    This should be compatible with ModelContainerPatchApplier.
-    """
-
-    def __init__(self, truss_dir: Path, logger: logging.Logger) -> None:
-        self._truss_dir = truss_dir
-        self._truss_config_path = self._truss_dir / "config.yaml"
-        self._truss_config = TrussConfig.from_yaml(self._truss_config_path)
-        self._logger = logger
-
-    def __call__(self, patches: List[Patch]):
-        # Apply model code patches immediately
-        # Aggregate config patches and apply at end
-        reqs = reqs_by_name(self._truss_config.requirements)
-        pkgs = system_packages_set(self._truss_config.system_packages)
-        new_config = self._truss_config
-        for patch in patches:
-            self._logger.debug(f"Applying patch {patch.to_dict()}")
-            action = patch.body.action
-            if isinstance(patch.body, ModelCodePatch):
-                model_code_patch: ModelCodePatch = patch.body
-                model_module_dir = self._truss_dir / self._truss_config.model_module_dir
-                apply_code_patch(model_module_dir, model_code_patch, self._logger)
-                continue
-            if isinstance(patch.body, PythonRequirementPatch):
-                py_req_patch: PythonRequirementPatch = patch.body
-                req = py_req_patch.requirement
-                req_name = identify_requirement_name(req)
-                if action == Action.REMOVE:
-                    del reqs[req_name]
-                    continue
-                if action == Action.ADD or Action.UPDATE:
-                    reqs[req_name] = req
-                continue
-            if isinstance(patch.body, SystemPackagePatch):
-                sys_pkg_patch: SystemPackagePatch = patch.body
-                pkg = sys_pkg_patch.package
-                if action == Action.REMOVE:
-                    pkgs.remove(pkg)
-                    continue
-                if action == Action.ADD or Action.UPDATE:
-                    pkgs.add(pkg)
-                    continue
-            # Each of EnvVarPatch and ExternalDataPatch can be expressed through an overwrite of the config,
-            # handled below
-            if isinstance(patch.body, EnvVarPatch):
-                continue
-            if isinstance(patch.body, ExternalDataPatch):
-                continue
-            if isinstance(patch.body, ConfigPatch):
-                new_config = TrussConfig.from_dict(patch.body.config)
-                continue
-            raise UnsupportedPatch(f"Unknown patch type {patch.type}")
 
-        new_config.write_to_yaml_file(self._truss_config_path)
+__all__ = ["TrussDirPatchApplier"]