hivekit 0.3.0__tar.gz → 0.3.1__tar.gz

{hivekit-0.3.0 → hivekit-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hivekit
-Version: 0.3.0
+Version: 0.3.1
 Summary: Toolkits for using hive agents, including CLI and SDK.
 License: 
                                          Apache License

{hivekit-0.3.0 → hivekit-0.3.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "hivekit"
-version = "0.3.0"
+version = "0.3.1"
 description = "Toolkits for using hive agents, including CLI and SDK."
 readme = "README.md"
 requires-python = ">=3.12"

{hivekit-0.3.0 → hivekit-0.3.1}/src/cli/config.py

@@ -29,11 +29,62 @@ class BaseModel(pydantic.BaseModel):
     model_config = ConfigDict(extra="forbid", coerce_numbers_to_str=True)
 
 
-# Per-sandbox resource caps. cpu is in whole cores; memory is in bytes (128Gi).
-# Values are k8s quantities (e.g. "500m", "2Gi"), normalized via parse_quantity
-# before comparison so every equivalent spelling is bounded uniformly.
-MAX_CPU_CORES = 64
-MAX_MEMORY_BYTES = 128 * 1024**3
+# Kubernetes caps DNS labels and label values at 63 bytes. The operator derives
+# object names/labels by appending suffixes to the experiment name (the longest
+# is "-coordinator"), so reserve that headroom to keep the derived names valid.
+K8S_LABEL_MAX_LENGTH = 63
+RESERVED_NAME_SUFFIX_LENGTH = len("-coordinator")
+MAX_EXPERIMENT_NAME_LENGTH = K8S_LABEL_MAX_LENGTH - RESERVED_NAME_SUFFIX_LENGTH
+# A name ending in '-' gets a random uniqueness hash appended (see now_2_hash),
+# which eats into the budget the user actually controls (their typed base name).
+AUTO_HASH_LENGTH = 7
+MAX_EXPERIMENT_BASE_NAME_LENGTH = MAX_EXPERIMENT_NAME_LENGTH - AUTO_HASH_LENGTH
+
+# Accelerator (GPU) types the cloud providers know how to schedule. Mirrors the
+# controller's LabelsByAcceleratorType switch. Unknown types are not rejected —
+# a provider may support more than we list here — but they trigger a warning.
+KNOWN_ACCELERATOR_TYPES = frozenset(
+    {
+        "a10",
+        "a100",
+        "a100-40gb",
+        "a100-80gb",
+        "b200",
+        "h100",
+        "h200",
+        "l4",
+        "l40s",
+        "t4",
+    }
+)
+
+# Kubernetes caps DNS labels and label values at 63 bytes. The operator derives
+# object names/labels by appending suffixes to the experiment name (the longest
+# is "-coordinator"), so reserve that headroom to keep the derived names valid.
+K8S_LABEL_MAX_LENGTH = 63
+RESERVED_NAME_SUFFIX_LENGTH = len("-coordinator")
+MAX_EXPERIMENT_NAME_LENGTH = K8S_LABEL_MAX_LENGTH - RESERVED_NAME_SUFFIX_LENGTH
+# A name ending in '-' gets a random uniqueness hash appended (see now_2_hash),
+# which eats into the budget the user actually controls (their typed base name).
+AUTO_HASH_LENGTH = 7
+MAX_EXPERIMENT_BASE_NAME_LENGTH = MAX_EXPERIMENT_NAME_LENGTH - AUTO_HASH_LENGTH
+# Accelerator (GPU) types the cloud providers know how to schedule. Mirrors the
+# controller's LabelsByAcceleratorType switch. Unknown types are not rejected —
+# a provider may support more than we list here — but they trigger a warning.
+KNOWN_ACCELERATOR_TYPES = frozenset(
+    {
+        "a10",
+        "a100",
+        "a100-40gb",
+        "a100-80gb",
+        "b200",
+        "h100",
+        "h200",
+        "l4",
+        "l40s",
+        "t4",
+    }
+)
 
 
 class ResourceConfig(BaseModel):
@@ -62,8 +113,6 @@ class ResourceConfig(BaseModel):
             raise ValueError(f"cpu is not a valid quantity (e.g. '1', '500m'), got: '{v}'")
         if cores <= 0:
             raise ValueError(f"cpu must be positive, got: '{v}'")
-        if cores > MAX_CPU_CORES:
-            raise ValueError(f"cpu must be at most {MAX_CPU_CORES} cores, got: '{v}'")
         return v
 
     @field_validator("memory")
@@ -75,10 +124,40 @@ class ResourceConfig(BaseModel):
             raise ValueError(f"memory is not a valid quantity (e.g. '2Gi', '512Mi'), got: '{v}'")
         if memory_bytes <= 0:
             raise ValueError(f"memory must be positive, got: '{v}'")
-        if memory_bytes > MAX_MEMORY_BYTES:
-            raise ValueError(f"memory must be at most 128Gi, got: '{v}'")
         return v
 
+    @field_validator("accelerators")
+    @classmethod
+    def validate_accelerators(cls, v):
+        # NOTE: KNOWN_ACCELERATOR_TYPES is a hardcoded mirror of the controller's
+        # switch, so it can drift out of sync. A better approach would be a new
+        # backend endpoint that lists the currently available GPU types, letting
+        # us validate against the live source of truth instead of this static set.
+        if v is None:
+            return v
+        parts = v.split(":")
+        if len(parts) != 2:
+            raise ValueError(
+                f"accelerators must be in '<type>:<count>' format (e.g. 'a100-80gb:8'), got: '{v}'"
+            )
+        gpu_type, count = parts[0].strip(), parts[1].strip()
+        if not gpu_type:
+            raise ValueError(f"accelerators type must not be empty, got: '{v}'")
+        try:
+            n = int(count)
+        except ValueError:
+            raise ValueError(f"accelerators count must be an integer, got: '{count}'")
+        if n <= 0:
+            raise ValueError(f"accelerators count must be positive, got: '{count}'")
+        if gpu_type not in KNOWN_ACCELERATOR_TYPES:
+            logger.warning(
+                "accelerators type '%s' is not among the known GPU types (%s); "
+                "any available GPUs may be used. Please confirm with the Hiverge team.",
+                gpu_type,
+                ", ".join(sorted(KNOWN_ACCELERATOR_TYPES)),
+            )
+        return f"{gpu_type}:{n}"
+
 
 class KeyValueSet(BaseModel):
     name: str
@@ -225,24 +304,14 @@ class RepoConfig(BaseModel):
         return v
 
 
-# Platform caps. One sandbox is provisioned per agent, so num_agents is bounded
-# by the max number of sandboxes. max_runtime_seconds is bounded by the maximum
-# runtime of an experiment (6 hours).
-MAX_SANDBOXES = 32
-MAX_RUNTIME_SECONDS = 6 * 60 * 60
-
-
 class RuntimeConfig(BaseModel):
     num_agents: int = Field(
         default=1,
         description="Number of agents to use in the experiment. Default to 1.",
     )
     max_runtime_seconds: int = Field(
-        default=MAX_RUNTIME_SECONDS,
-        description=(
-            "Maximum runtime for the experiment in seconds. -1 means no limit. "
-            f"Defaults to the platform maximum of {MAX_RUNTIME_SECONDS} (6 hours)."
-        ),
+        default=-1,
+        description="Maximum runtime for the experiment in seconds. -1 means no limit.",
     )
     max_iterations: int = Field(
         default=-1,
@@ -256,30 +325,21 @@ class RuntimeConfig(BaseModel):
     @field_validator("num_agents")
     @classmethod
     def validate_num_agents(cls, v):
-        # One sandbox per agent; the platform provisions at most MAX_SANDBOXES.
+        # One sandbox is provisioned per agent.
         if v < 1:
             raise ValueError(f"num_agents must be at least 1, got {v}.")
-        if v > MAX_SANDBOXES:
-            raise ValueError(
-                f"num_agents must be at most {MAX_SANDBOXES} (one sandbox per agent), got {v}."
-            )
         return v
 
     @field_validator("max_runtime_seconds")
     @classmethod
     def validate_max_runtime_seconds(cls, v):
-        # -1 is the sentinel for "no limit"; any positive value is capped at the
-        # platform's maximum experiment runtime.
+        # -1 is the sentinel for "no limit"
         if v == -1:
             return v
         if v < 1:
             raise ValueError(
                 f"max_runtime_seconds must be -1 (no limit) or a positive integer, got {v}."
             )
-        if v > MAX_RUNTIME_SECONDS:
-            raise ValueError(
-                f"max_runtime_seconds must be at most {MAX_RUNTIME_SECONDS} (6 hours), got {v}."
-            )
         return v
 
 
@@ -295,15 +355,24 @@ class HiveConfig(BaseModel):
     @field_validator("experiment_name")
     @classmethod
     def validate_experiment_name(cls, v):
-        if v.endswith("-"):
+        base_name = v
+        auto_hashed = v.endswith("-")
+        if auto_hashed:
             v = f"{v}{now_2_hash()}"
         if not re.fullmatch(r"[a-z0-9]([a-z0-9-]*[a-z0-9])?", v):
             raise ValueError(
-                f"Experiment name must be a valid DNS label (RFC 1123): [a-z0-9] separated by '-', got: '{v}'"
+                f"Experiment name must be a valid DNS label (RFC 1123): [a-z0-9] separated by '-', got: '{base_name}'"
             )
-        if len(v) > 63:
+        if len(v) > MAX_EXPERIMENT_NAME_LENGTH:
+            if auto_hashed:
+                raise ValueError(
+                    f"Experiment name must be no more than {MAX_EXPERIMENT_BASE_NAME_LENGTH} "
+                    f"characters when it ends in '-', got {len(base_name)}: '{base_name}'. "
+                    f"Shorten the name or drop the trailing '-'."
+                )
             raise ValueError(
-                f"Experiment name must be no more than 63 characters, got {len(v)}: '{v}'"
+                f"Experiment name must be no more than {MAX_EXPERIMENT_NAME_LENGTH} "
+                f"characters, got {len(v)}: '{v}'. Shorten the name."
             )
         return v
 

{hivekit-0.3.0 → hivekit-0.3.1}/src/hivekit.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hivekit
-Version: 0.3.0
+Version: 0.3.1
 Summary: Toolkits for using hive agents, including CLI and SDK.
 License: 
                                          Apache License

{hivekit-0.3.0 → hivekit-0.3.1}/src/hivekit.egg-info/top_level.txt

@@ -1 +1,2 @@
 cli
+sdk

{hivekit-0.3.0 → hivekit-0.3.1}/tests/test_config.py

@@ -10,8 +10,6 @@ import pytest
 import yaml
 
 from cli.config import (
-    MAX_RUNTIME_SECONDS,
-    MAX_SANDBOXES,
     HiveConfig,
     RepoConfig,
     ResourceConfig,
@@ -203,7 +201,8 @@ class TestFileExistenceValidation:
 
 
 class TestExperimentNameValidation:
-    """RFC 1123 DNS label validation: [a-z0-9], separated by '-', max 63 chars."""
+    """RFC 1123 DNS label validation: [a-z0-9], separated by '-', max 51 chars
+    (63-byte K8s cap minus the operator's '-coordinator' suffix)."""
 
     def test_valid_name(self, base_config):
         config = load_config(base_config, overrides=["experiment_name=my-exp-1"])
@@ -229,15 +228,42 @@ class TestExperimentNameValidation:
         with pytest.raises(Exception, match="DNS label"):
             load_config(base_config, overrides=["experiment_name=my.exp"])
 
+    def test_dns_error_reports_typed_name_not_expanded(self, base_config):
+        # A trailing '-' triggers the auto-hash, but an invalid-char error must
+        # report what the user typed, not the non-deterministic expanded value.
+        with pytest.raises(Exception, match="got: 'my_exp-'"):
+            load_config(base_config, overrides=["experiment_name=my_exp-"])
+
     def test_rejects_too_long(self, base_config):
-        with pytest.raises(Exception, match="63 characters"):
-            load_config(base_config, overrides=["experiment_name=" + "a" * 64])
+        # 52 chars exceeds the effective limit (63 minus the operator's
+        # "-coordinator" suffix), even though it is under the raw K8s 63 cap.
+        with pytest.raises(Exception, match="no more than 51 characters"):
+            load_config(base_config, overrides=["experiment_name=" + "a" * 52])
+
+    def test_accepts_max_length(self, base_config):
+        config = load_config(base_config, overrides=["experiment_name=" + "a" * 51])
+        assert config.experiment_name == "a" * 51
+
+    def test_rejects_too_long_with_auto_hash(self, base_config):
+        # A trailing '-' name gets a 7-char hash appended, so the base budget is
+        # 44. 45 chars (incl. the '-') is under the plain 51 limit but tips over
+        # once the hash lands. The error must report the base, not the expansion.
+        name = "a" * 44 + "-"  # 45 chars typed
+        with pytest.raises(Exception, match="no more than 44 characters when it ends in '-'"):
+            load_config(base_config, overrides=["experiment_name=" + name])
+
+    def test_accepts_max_base_length_with_auto_hash(self, base_config):
+        # 44 chars (43 'a's + '-') expands to exactly 51 with the hash.
+        name = "a" * 43 + "-"
+        config = load_config(base_config, overrides=["experiment_name=" + name])
+        assert config.experiment_name.startswith("a" * 43 + "-")
+        assert len(config.experiment_name) == 51
 
 
 class TestNumAgentsValidation:
-    """num_agents is bounded to [1, MAX_SANDBOXES] (one sandbox per agent)."""
+    """Tests num_agents is valid."""
 
-    @pytest.mark.parametrize("value", [1, 5, MAX_SANDBOXES])
+    @pytest.mark.parametrize("value", [1, 5])
     def test_valid(self, value):
         assert RuntimeConfig(num_agents=value).num_agents == value
 
@@ -249,37 +275,26 @@ class TestNumAgentsValidation:
         with pytest.raises(Exception, match="at least 1"):
             RuntimeConfig(num_agents=value)
 
-    def test_rejects_above_cap(self):
-        with pytest.raises(Exception, match=f"at most {MAX_SANDBOXES}"):
-            RuntimeConfig(num_agents=MAX_SANDBOXES + 1)
-
 
 class TestMaxRuntimeSecondsValidation:
-    """max_runtime_seconds is -1 (no limit) or in [1, MAX_RUNTIME_SECONDS]."""
+    """Tests max_runtime_seconds is valid."""
 
-    @pytest.mark.parametrize("value", [-1, 1, 7200, MAX_RUNTIME_SECONDS])
+    @pytest.mark.parametrize("value", [-1, 1, 7200])
     def test_valid(self, value):
         assert RuntimeConfig(max_runtime_seconds=value).max_runtime_seconds == value
 
-    def test_default_is_platform_cap(self):
-        # Previously unlimited (-1); now bounded to the platform maximum.
-        assert RuntimeConfig().max_runtime_seconds == MAX_RUNTIME_SECONDS
+    def test_default_is_inf(self):
+        # Default is unlimited (-1).
+        assert RuntimeConfig().max_runtime_seconds == -1
 
     @pytest.mark.parametrize("value", [0, -2, -100])
     def test_rejects_non_sentinel_non_positive(self, value):
         with pytest.raises(Exception, match="-1 .no limit. or a positive integer"):
             RuntimeConfig(max_runtime_seconds=value)
 
-    def test_rejects_above_cap(self):
-        with pytest.raises(Exception, match="at most"):
-            RuntimeConfig(max_runtime_seconds=MAX_RUNTIME_SECONDS + 1)
-
-    def test_cap_is_six_hours(self):
-        assert MAX_RUNTIME_SECONDS == 6 * 60 * 60
-
 
 class TestResourceCpuValidation:
-    """cpu is a k8s quantity bounded to (0, 64] cores, spelling-invariant."""
+    """cpu is a k8s quantity; must be positive, spelling-invariant."""
 
     @pytest.mark.parametrize("value", ["1", "500m", "64", "64000m", "0.5"])
     def test_valid(self, value):
@@ -288,11 +303,6 @@ class TestResourceCpuValidation:
     def test_default(self):
         assert ResourceConfig().cpu == "1"
 
-    @pytest.mark.parametrize("value", ["65", "64001m", "128"])
-    def test_rejects_above_cap(self, value):
-        with pytest.raises(Exception, match="at most 64 cores"):
-            ResourceConfig(cpu=value)
-
     @pytest.mark.parametrize("value", ["0", "-1"])
     def test_rejects_non_positive(self, value):
         with pytest.raises(Exception, match="must be positive"):
@@ -304,7 +314,7 @@ class TestResourceCpuValidation:
 
 
 class TestResourceMemoryValidation:
-    """memory is a k8s quantity bounded to (0, 128Gi] bytes, spelling-invariant."""
+    """memory is a k8s quantity, spelling-invariant."""
 
     @pytest.mark.parametrize("value", ["2Gi", "512Mi", "128Gi", "131072Mi", "128G"])
     def test_valid(self, value):
@@ -313,11 +323,6 @@ class TestResourceMemoryValidation:
     def test_default(self):
         assert ResourceConfig().memory == "2Gi"
 
-    @pytest.mark.parametrize("value", ["129Gi", "256Gi", "131073Mi"])
-    def test_rejects_above_cap(self, value):
-        with pytest.raises(Exception, match="at most 128Gi"):
-            ResourceConfig(memory=value)
-
     @pytest.mark.parametrize("value", ["0", "-1Gi"])
     def test_rejects_non_positive(self, value):
         with pytest.raises(Exception, match="must be positive"):
@@ -329,6 +334,63 @@ class TestResourceMemoryValidation:
             ResourceConfig(memory="64GiB")
 
 
+class TestResourceAcceleratorsValidation:
+    """accelerators is a '<type>:<count>' string; count is a positive int and
+    unknown types are warned about but not rejected."""
+
+    @pytest.mark.parametrize("value", ["a100:2", "a100-80gb:8", "h100:1", "t4:4", "l40s:16"])
+    def test_valid_known_types(self, value):
+        assert ResourceConfig(accelerators=value).accelerators == value
+
+    def test_default_is_none(self):
+        assert ResourceConfig().accelerators is None
+
+    def test_unknown_type_is_allowed_with_warning(self, caplog):
+        # The "hivekit" logger has propagate=False, so attach caplog's handler
+        # directly rather than relying on propagation to the root logger.
+        hivekit_logger = logging.getLogger("hivekit")
+        hivekit_logger.addHandler(caplog.handler)
+        try:
+            with caplog.at_level(logging.WARNING, logger="hivekit"):
+                assert ResourceConfig(accelerators="mi300x:2").accelerators == "mi300x:2"
+        finally:
+            hivekit_logger.removeHandler(caplog.handler)
+        assert any("not among the known GPU types" in r.getMessage() for r in caplog.records)
+
+    @pytest.mark.parametrize("value", ["a100", "a100:2:1", "a100-80gb"])
+    def test_rejects_bad_format(self, value):
+        with pytest.raises(Exception, match="<type>:<count>"):
+            ResourceConfig(accelerators=value)
+
+    def test_rejects_empty_type(self):
+        with pytest.raises(Exception, match="type must not be empty"):
+            ResourceConfig(accelerators=":2")
+
+    @pytest.mark.parametrize("value", ["a100:two", "a100:2.5"])
+    def test_rejects_non_integer_count(self, value):
+        with pytest.raises(Exception, match="count must be an integer"):
+            ResourceConfig(accelerators=value)
+
+    @pytest.mark.parametrize("value", ["a100:0", "a100:-1"])
+    def test_rejects_non_positive_count(self, value):
+        with pytest.raises(Exception, match="count must be positive"):
+            ResourceConfig(accelerators=value)
+
+    @pytest.mark.parametrize(
+        "value,expected",
+        [
+            (" a100 : 2 ", "a100:2"),
+            ("a100:2", "a100:2"),
+            ("a100-80gb : 08", "a100-80gb:8"),
+            ("h100:\t1", "h100:1"),
+        ],
+    )
+    def test_normalizes_to_canonical_form(self, value, expected):
+        # Incidental whitespace and non-canonical integer spellings are stripped
+        # so the stored value always matches the '<type>:<count>' invariant.
+        assert ResourceConfig(accelerators=value).accelerators == expected
+
+
 class TestRawYaml:
     """Tests for the `raw_yaml` capture on load_config."""
 

{hivekit-0.3.0 → hivekit-0.3.1}/tests/test_experiment.py

@@ -7,7 +7,6 @@ Unit tests for experiment builder functions.
 """
 
 from cli.config import (
-    MAX_RUNTIME_SECONDS,
     HiveConfig,
     KeyValueSet,
     PortConfig,
@@ -42,7 +41,7 @@ class TestBuildExperimentCRD:
         assert result["kind"] == "Experiment"
         assert result["metadata"]["name"] == "test-exp"
         assert result["spec"]["runtime"]["numAgents"] == 1
-        assert result["spec"]["runtime"]["maxRuntimeSeconds"] == MAX_RUNTIME_SECONDS
+        assert result["spec"]["runtime"]["maxRuntimeSeconds"] == -1
         assert result["spec"]["runtime"]["maxIterations"] == -1
         assert "source" not in result["spec"]["repo"]
         assert "branch" not in result["spec"]["repo"]

{hivekit-0.3.0 → hivekit-0.3.1}/tests/test_overrides.py

@@ -5,7 +5,7 @@
 import pytest
 import yaml
 
-from cli.config import MAX_RUNTIME_SECONDS, load_config
+from cli.config import load_config
 
 MINIMAL_CONFIG = {
     "experiment_name": "test-exp",
@@ -69,7 +69,7 @@ class TestApplyOverrides:
 
     def test_delete_restores_default(self, base_config):
         config = load_config(base_config, overrides=["~runtime.max_runtime_seconds"])
-        assert config.runtime.max_runtime_seconds == MAX_RUNTIME_SECONDS
+        assert config.runtime.max_runtime_seconds == -1
 
     def test_delete_nested(self, base_config):
         config = load_config(base_config, overrides=["~sandbox.resources.cpu"])