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

truss/{validation.py → base/validation.py}

@@ -1,16 +1,48 @@
+import math
 import re
-from pathlib import Path
-from typing import Pattern, Set
+from pathlib import PurePosixPath
+from typing import Any, Dict, Pattern
 
-from truss.constants import REGISTRY_BUILD_SECRET_PREFIX
-from truss.errors import ValidationError
+from truss.base.constants import REGISTRY_BUILD_SECRET_PREFIX
+from truss.base.errors import ValidationError
 
 SECRET_NAME_MATCH_REGEX: Pattern[str] = re.compile(r"^[-._a-zA-Z0-9]+$")
 MILLI_CPU_REGEX: Pattern[str] = re.compile(r"^[0-9.]*m$")
 MEMORY_REGEX: Pattern[str] = re.compile(r"^[0-9.]*(\w*)$")
-MEMORY_UNITS: Set[str] = set(
-    ["k", "M", "G", "T", "P", "E", "Ki", "Mi", "Gi", "Ti", "Pi", "Ei"]
-)
+MEMORY_UNITS: Dict[str, int] = {
+    "k": 10**3,
+    "M": 10**6,
+    "G": 10**9,
+    "T": 10**12,
+    "P": 10**15,
+    "E": 10**18,
+    "Ki": 1024,
+    "Mi": 1024**2,
+    "Gi": 1024**3,
+    "Ti": 1024**4,
+    "Pi": 1024**5,
+    "Ei": 1024**6,
+}
+
+_MODEL_NAME_RE = re.compile(r"^[a-zA-Z0-9_-]+-[0-9a-f]{8}$")
+
+
+def is_valid_model_name(model_name: str) -> bool:
+    return bool(_MODEL_NAME_RE.match(model_name))
+
+
+def validate_secret_to_path_mapping(secret_to_path_mapping: Dict[str, str]) -> None:
+    if not isinstance(secret_to_path_mapping, dict):
+        raise ValueError("Please pass a valid mapping for `secret_to_path_mapping`.")
+
+    for secret_name, path in secret_to_path_mapping.items():
+        validate_secret_name(secret_name)
+        k8s_valid_name = re.sub("[^0-9a-zA-Z]+", "-", secret_name)
+        if secret_name != k8s_valid_name:
+            raise ValueError(
+                f"Secrets used in builds must follow Kubernetes object naming conventions.  Name `{secret_name}` is not valid. "
+                f"Please use only alphanumeric characters and `-`."
+            )
 
 
 def validate_secret_name(secret_name: str) -> None:
@@ -53,13 +85,14 @@ def validate_cpu_spec(cpu_spec: str) -> None:
         raise ValidationError(f"Invalid cpu specification {cpu_spec}")
 
 
-def validate_memory_spec(mem_spec: str) -> None:
+def validate_memory_spec(mem_spec: str) -> int:
+    """Validate the memory spec and return the requested memory in bytes."""
     if not isinstance(mem_spec, str):
         raise ValidationError(
             f"{mem_spec} needs to be a string, but is {type(mem_spec)}"
         )
     if _is_numeric(mem_spec):
-        return
+        return math.ceil(float(mem_spec))
 
     match = MEMORY_REGEX.search(mem_spec)
     if match is None:
@@ -68,6 +101,7 @@ def validate_memory_spec(mem_spec: str) -> None:
     unit = match.group(1)
     if unit not in MEMORY_UNITS:
         raise ValidationError(f"Invalid memory unit {unit} in {mem_spec}")
+    return math.ceil(float(mem_spec.strip(unit)) * MEMORY_UNITS[unit])
 
 
 def _is_numeric(number_like: str) -> bool:
@@ -81,9 +115,24 @@ 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 PurePosixPath -- TrussServer always runs on a Posix machine.
     """
-    if path and not Path(path).is_absolute():
+    if path and not PurePosixPath(path).is_absolute():
         raise ValidationError(
             f"Invalid relative python executable path {path}. Provide an absolute path"
         )
+
+
+def validate_node_count(node_count: Any) -> None:
+    fieldpath = "resources.node_count"
+    if node_count is None:
+        return None
+    if not isinstance(node_count, int):
+        raise ValidationError(
+            f"{fieldpath} must be a postiive integer. Got {node_count} of type '{type(node_count)}'"
+        )
+    if node_count < 1:
+        raise ValidationError(
+            f"{fieldpath} must be a positive integer. Got {node_count}."
+        )