flowmesh-sdk-stack 0.1.1__tar.gz → 0.1.3__tar.gz

{flowmesh_sdk_stack-0.1.1/src/flowmesh_sdk_stack.egg-info → flowmesh_sdk_stack-0.1.3}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: flowmesh-sdk-stack
-Version: 0.1.1
+Version: 0.1.3
 Summary: FlowMesh SDK stack client
 License-Expression: Apache-2.0
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: flowmesh-sdk==0.1.1
+Requires-Dist: flowmesh-sdk==0.1.3
 Requires-Dist: httpx>=0.27.0
 Requires-Dist: pyyaml>=6.0.0
 Requires-Dist: docker>=7.1.0

{flowmesh_sdk_stack-0.1.1 → flowmesh_sdk_stack-0.1.3}/pyproject.toml

@@ -4,14 +4,14 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "flowmesh-sdk-stack"
-version = "0.1.1"
+version = "0.1.3"
 description = "FlowMesh SDK stack client"
 readme = "README.md"
 requires-python = ">=3.12"
 license = "Apache-2.0"
 license-files = ["LICENSE"]
 dependencies = [
-    "flowmesh-sdk==0.1.1",
+    "flowmesh-sdk==0.1.3",
     "httpx>=0.27.0",
     "pyyaml>=6.0.0",
     "docker>=7.1.0",

{flowmesh_sdk_stack-0.1.1 → flowmesh_sdk_stack-0.1.3/src/flowmesh_sdk_stack.egg-info}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: flowmesh-sdk-stack
-Version: 0.1.1
+Version: 0.1.3
 Summary: FlowMesh SDK stack client
 License-Expression: Apache-2.0
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: flowmesh-sdk==0.1.1
+Requires-Dist: flowmesh-sdk==0.1.3
 Requires-Dist: httpx>=0.27.0
 Requires-Dist: pyyaml>=6.0.0
 Requires-Dist: docker>=7.1.0

{flowmesh_sdk_stack-0.1.1 → flowmesh_sdk_stack-0.1.3}/src/flowmesh_sdk_stack.egg-info/requires.txt

@@ -1,4 +1,4 @@
-flowmesh-sdk==0.1.1
+flowmesh-sdk==0.1.3
 httpx>=0.27.0
 pyyaml>=6.0.0
 docker>=7.1.0

{flowmesh_sdk_stack-0.1.1 → flowmesh_sdk_stack-0.1.3}/src/flowmesh_stack/env_schema.py

@@ -1,6 +1,7 @@
 """Environment schema definitions and pure validation helpers."""
 
 import enum
+import operator
 from collections.abc import Callable, Iterable, Mapping
 from dataclasses import dataclass, field
 from logging import _nameToLevel as LOG_LEVELS
@@ -34,7 +35,9 @@ class EnvVar:
     use_default: bool = False
     choices: Iterable[str] | None = None
     min_value: float | None = None
+    min_inclusive: bool = True
     max_value: float | None = None
+    max_inclusive: bool = True
     min_length: int | None = None
     ensure_path: Literal["error", "warn", "create"] | None = None
     url_schemes: set[str] | None = None
@@ -133,19 +136,13 @@ def validate_env_values(
                     if int_value is None:
                         errors.append(f"{var.key} must be an integer")
                         continue
-                    if var.min_value is not None and int_value < var.min_value:
-                        errors.append(f"{var.key} must be >= {int(var.min_value)}")
-                    if var.max_value is not None and int_value > var.max_value:
-                        errors.append(f"{var.key} must be <= {int(var.max_value)}")
+                    _check_value_range(var, int_value, errors)
                 case EnvVarType.FLOAT:
                     float_value = parse_float(raw)
                     if float_value is None:
                         errors.append(f"{var.key} must be a number")
                         continue
-                    if var.min_value is not None and float_value < var.min_value:
-                        errors.append(f"{var.key} must be >= {var.min_value}")
-                    if var.max_value is not None and float_value > var.max_value:
-                        errors.append(f"{var.key} must be <= {var.max_value}")
+                    _check_value_range(var, float_value, errors)
                 case EnvVarType.BOOL:
                     if parse_bool(raw) is None:
                         errors.append(
@@ -213,6 +210,36 @@ def require_all_or_none(
         errors.append(f"Either all or none of {', '.join(keys)} must be set")
 
 
+_COMPARE_OPS = {
+    "<": operator.lt,
+    "<=": operator.le,
+    ">": operator.gt,
+    ">=": operator.ge,
+}
+
+
+def _check_value_range(var: EnvVar, value: float, errors: list[str]) -> None:
+    comp: Literal["<", "<=", ">", ">="]
+    if var.min_value is not None:
+        comp = ">=" if var.min_inclusive else ">"
+        _check_bound(var, value, var.min_value, comp, errors)
+    if var.max_value is not None:
+        comp = "<=" if var.max_inclusive else "<"
+        _check_bound(var, value, var.max_value, comp, errors)
+
+
+def _check_bound(
+    var: EnvVar,
+    value: float,
+    bound: float,
+    comparison: Literal["<", "<=", ">", ">="],
+    errors: list[str],
+) -> None:
+    op = _COMPARE_OPS[comparison]
+    if not op(value, bound):
+        errors.append(f"{var.key} must be {comparison} {bound}")
+
+
 def _ensure_path(raw: str, var: EnvVar, errors: list[str], warnings: list[str]) -> None:
     if not raw:
         errors.append(f"{var.key} must be a non-empty path")

{flowmesh_sdk_stack-0.1.1 → flowmesh_sdk_stack-0.1.3}/src/flowmesh_stack/workers.py

@@ -65,12 +65,20 @@ def create_workers(
     targets: str = "all",
     config_paths: list[Path] | None = None,
     config_raw: list[str] | None = None,
+    name_template: str | None = None,
+    slug: str | None = None,
 ) -> list[tuple[str, dict[str, Any]]]:
     """Create node workers from configs or built-in cpu/gpu presets.
 
     When ``kind`` is "gpu", if ``count`` is equal to 1, a single worker with the
     specified GPU targets will be created. If ``count`` is greater than 1, one worker
     will be created per GPU target, and the number of targets must match ``count``.
+
+    For the built-in cpu/gpu presets, ``slug`` prefixes the generated worker
+    aliases so names are scoped to a stack, and ``name_template`` overrides the
+    naming entirely (placeholders ``{slug}``, ``{kind}``, ``{idx}``, ``{gpu}``).
+    Both are ignored when ``config_paths`` / ``config_raw`` are provided, since
+    those payloads carry their own aliases.
     """
     payloads = _payloads_for_worker_create(
         kind=kind,
@@ -78,6 +86,8 @@ def create_workers(
         targets=targets,
         config_paths=config_paths,
         config_raw=config_raw,
+        name_template=name_template,
+        slug=slug,
     )
     if not payloads:
         return []
@@ -162,12 +172,47 @@ def detect_gpu_targets(targets: str) -> list[str]:
     return [item.strip() for item in result.stdout.splitlines() if item.strip()]
 
 
+_ALIAS_FIELDS = "{slug}, {kind}, {idx}, {gpu}"
+
+
+class _StrictFormatDict(dict[str, Any]):
+    def __missing__(self, key: str) -> Any:
+        raise KeyError(key)
+
+
+def _worker_alias(
+    kind: str,
+    idx: int,
+    slug: str | None,
+    template: str | None,
+    gpu: str | None = None,
+) -> str:
+    if template is None:
+        template = (
+            ("{slug}_" if slug else "")
+            + f"worker_{kind}_"
+            + ("{idx}" if gpu is None else "{gpu}")
+        )
+    fields: dict[str, Any] = {"slug": slug or "", "kind": kind, "idx": idx}
+    if gpu is not None:
+        fields["gpu"] = gpu
+    try:
+        return template.format_map(_StrictFormatDict(fields))
+    except (KeyError, IndexError, ValueError) as exc:
+        raise FlowMeshError(
+            f"invalid --name-template ({exc}); "
+            f"available placeholders: {_ALIAS_FIELDS}"
+        ) from exc
+
+
 def _payloads_for_worker_create(
     kind: str,
     count: int,
     targets: str,
     config_paths: list[Path] | None,
     config_raw: list[str] | None,
+    name_template: str | None = None,
+    slug: str | None = None,
 ) -> list[tuple[str, str]]:
     if count < 1:
         raise FlowMeshError("Worker count must be at least 1.")
@@ -183,25 +228,17 @@ def _payloads_for_worker_create(
             _extend_payloads(payloads, f"worker from raw#{idx}", raw)
         return payloads
 
+    specs: list[tuple[str, dict[str, Any], str]]  # alias, worker_config, label
     if kind == "cpu":
-        return [
+        specs = [
             (
-                json.dumps(
-                    {
-                        "provider": "docker",
-                        "init_on_start": True,
-                        "worker_config": {
-                            "worker_type": "cpu",
-                            "worker_alias": f"worker_cpu_{idx}",
-                        },
-                    }
-                ),
+                (alias := _worker_alias("cpu", idx, slug, name_template)),
+                {"worker_type": "cpu", "worker_alias": alias},
                 "CPU worker",
             )
             for idx in range(count)
         ]
-
-    if kind == "gpu":
+    elif kind == "gpu":
         raw_gpu_ids = detect_gpu_targets(targets)
         gpu_ids: list[int] = []
         for raw_gpu_id in raw_gpu_ids:
@@ -217,47 +254,62 @@ def _payloads_for_worker_create(
                     f"Consider setting count={len(gpu_ids)} or specifying exactly "
                     f"{count} GPU targets."
                 )
-            gpu_payloads = [
+            specs = [
                 (
-                    json.dumps(
-                        {
-                            "provider": "docker",
-                            "init_on_start": True,
-                            "worker_config": {
-                                "worker_type": "gpu",
-                                "cuda_devices": [gpu_id],
-                                "worker_alias": f"worker_gpu_{gpu_id}",
-                            },
-                        }
+                    (
+                        alias := _worker_alias(
+                            "gpu", idx, slug, name_template, gpu=str(gpu_id)
+                        )
                     ),
+                    {
+                        "worker_type": "gpu",
+                        "cuda_devices": [gpu_id],
+                        "worker_alias": alias,
+                    },
                     f"GPU worker for GPU {gpu_id}",
                 )
-                for gpu_id in gpu_ids
+                for idx, gpu_id in enumerate(gpu_ids)
             ]
         else:
             worker_suffix = "all" if targets == "all" else "_".join(raw_gpu_ids)
-            gpu_payloads = [
+            specs = [
                 (
-                    json.dumps(
-                        {
-                            "provider": "docker",
-                            "init_on_start": True,
-                            "worker_config": {
-                                "worker_type": "gpu",
-                                "cuda_devices": gpu_ids,
-                                "worker_alias": f"worker_gpu_{worker_suffix}",
-                            },
-                        }
+                    (
+                        alias := _worker_alias(
+                            "gpu", 0, slug, name_template, gpu=worker_suffix
+                        )
                     ),
+                    {
+                        "worker_type": "gpu",
+                        "cuda_devices": gpu_ids,
+                        "worker_alias": alias,
+                    },
                     f"GPU worker for GPUs {', '.join(raw_gpu_ids)}",
                 )
             ]
+    else:
+        raise FlowMeshError("worker up expects kind cpu|gpu or use --config")
+
+    aliases = [alias for alias, _, _ in specs]
+    if len(set(aliases)) != len(aliases):
+        raise FlowMeshError(
+            "--name-template produced duplicate worker names; "
+            "include {idx} or {gpu} to disambiguate"
+        )
 
-        if not gpu_payloads:
-            raise FlowMeshError("No GPUs detected or specified.")
-        return gpu_payloads
-
-    raise FlowMeshError("worker up expects kind cpu|gpu or use --config")
+    return [
+        (
+            json.dumps(
+                {
+                    "provider": "docker",
+                    "init_on_start": True,
+                    "worker_config": worker_config,
+                }
+            ),
+            label,
+        )
+        for _, worker_config, label in specs
+    ]
 
 
 def _extend_payloads(