alloc 0.0.8__tar.gz → 0.0.9__tar.gz

{alloc-0.0.8 → alloc-0.0.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alloc
-Version: 0.0.8
+Version: 0.0.9
 Summary: Engineer-first training calibration: estimate VRAM fit, profile short runs, and pick GPU configs under real budget constraints.
 Author-email: Alloc Labs <hello@alloclabs.com>
 License-Expression: Apache-2.0
@@ -40,7 +40,7 @@ alloc run python train.py
 ```
 
 ```
-alloc v0.0.2 — Calibrate
+alloc v0.0.8 — Calibrate
 
  Run Summary
   Peak VRAM       31.2 GB / 40.0 GB (A100)

{alloc-0.0.8 → alloc-0.0.9}/README.md

@@ -12,7 +12,7 @@ alloc run python train.py
 ```
 
 ```
-alloc v0.0.2 — Calibrate
+alloc v0.0.8 — Calibrate
 
  Run Summary
   Peak VRAM       31.2 GB / 40.0 GB (A100)

{alloc-0.0.8 → alloc-0.0.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "alloc"
-version = "0.0.8"
+version = "0.0.9"
 description = "Engineer-first training calibration: estimate VRAM fit, profile short runs, and pick GPU configs under real budget constraints."
 readme = "README.md"
 license = "Apache-2.0"

{alloc-0.0.8 → alloc-0.0.9}/src/alloc/__init__.py

@@ -9,7 +9,7 @@ _warnings.filterwarnings("ignore", category=FutureWarning, module=r"torch\.cuda"
 _warnings.filterwarnings("ignore", category=DeprecationWarning, module=r"torch\.cuda")
 del _warnings
 
-__version__ = "0.0.8"
+__version__ = "0.0.9"
 
 from alloc.ghost import ghost, GhostReport
 from alloc.callbacks import AllocCallback as HuggingFaceCallback

{alloc-0.0.8 → alloc-0.0.9}/src/alloc/cli.py

@@ -2400,23 +2400,33 @@ def whoami(
             profile = _get("/profile")
             fleet = _get("/gpu-fleet")
         else:
-            if json_output:
+            # whoami is a status command — report structured result, exit 0
+            if e.response.status_code == 401:
+                out["token_status"] = "expired"
+            else:
+                out["token_status"] = "error"
                 out["error"] = f"API error {e.response.status_code}"
+            if json_output:
                 _print_json(out)
             else:
-                console.print(f"[red]API error {e.response.status_code}[/red]")
+                if e.response.status_code == 401:
+                    console.print("[yellow]Token expired.[/yellow]")
+                else:
+                    console.print(f"[red]API error {e.response.status_code}[/red]")
                 console.print("[dim]Run: alloc login[/dim]")
-            raise typer.Exit(1)
+            return
     except httpx.ConnectError:
+        out["token_status"] = "unreachable"
+        out["error"] = f"Cannot connect to {api_url}"
         if json_output:
-            out["error"] = f"Cannot connect to {api_url}"
             _print_json(out)
         else:
             console.print(f"[red]Cannot connect to {api_url}[/red]")
-        raise typer.Exit(1)
+        return
 
     # API validated the token — now we know login is real
     out["logged_in"] = True
+    out["token_status"] = "valid"
 
     gpus = fleet.get("gpus") or []
     fleet_count = len([g for g in gpus if g.get("fleet_status") == "in_fleet"])
@@ -3565,7 +3575,14 @@ def _infer_parallel_topology_from_env(*, num_gpus_detected: int, config_intercon
         strategy = "pp+dp" if (dp is not None and dp > 1) else "pp"
     elif dp is not None and dp > 1:
         strategy = "ddp"
-    # If none of the above matched, strategy stays None (unknown)
+    elif strategy is None and num_gpus_detected > 1 and not has_tp and not has_pp:
+        # Multiple GPUs detected via NVML with no TP/PP env vars →
+        # DDP is PyTorch's default and the only realistic inference.
+        # This is NOT the old `or "ddp"` — it only fires when probe
+        # actually observed multiple GPU processes.
+        strategy = "ddp"
+        if dp is None:
+            dp = num_gpus_detected
 
     return {
         "num_nodes": nnodes or 1,

{alloc-0.0.8 → alloc-0.0.9}/src/alloc/extractor_runner.py

@@ -281,7 +281,30 @@ def main():
             "activation_method": activation_result.get("activation_method"),
         }
     else:
-        result = {"status": "no_model"}
+        # No model found — check if this is a distributed training script
+        # that hides the model inside __main__ guard or main()
+        _is_dist = False
+        try:
+            import torch.distributed as _dist_mod
+            if _dist_mod.is_initialized():
+                _is_dist = True
+        except Exception:
+            pass
+        if not _is_dist:
+            # Check if module imported distributed primitives
+            for attr_name in dir(module):
+                try:
+                    obj = getattr(module, attr_name)
+                    mod_name = getattr(obj, "__module__", "") or ""
+                    if "torch.distributed" in mod_name or "torch.nn.parallel" in mod_name:
+                        _is_dist = True
+                        break
+                except Exception:
+                    continue
+        if _is_dist:
+            result = {"status": "error_distributed", "error": "no model found — script uses distributed training"}
+        else:
+            result = {"status": "no_model"}
 
     with open(sidecar_path, "w") as f:
         json.dump(result, f)

{alloc-0.0.8 → alloc-0.0.9}/src/alloc.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alloc
-Version: 0.0.8
+Version: 0.0.9
 Summary: Engineer-first training calibration: estimate VRAM fit, profile short runs, and pick GPU configs under real budget constraints.
 Author-email: Alloc Labs <hello@alloclabs.com>
 License-Expression: Apache-2.0
@@ -40,7 +40,7 @@ alloc run python train.py
 ```
 
 ```
-alloc v0.0.2 — Calibrate
+alloc v0.0.8 — Calibrate
 
  Run Summary
   Peak VRAM       31.2 GB / 40.0 GB (A100)

{alloc-0.0.8 → alloc-0.0.9}/tests/test_auth.py

@@ -68,6 +68,34 @@ def test_whoami_not_logged_in_json(tmp_path: Path):
     assert data["api_url"] == "https://api.example.com"
 
 
+def test_whoami_stale_token_json(tmp_path: Path):
+    """Stale token should exit 0 with token_status: expired."""
+    mock_resp = MagicMock()
+    mock_resp.status_code = 401
+    mock_resp.raise_for_status.side_effect = httpx.HTTPStatusError(
+        "Unauthorized", request=MagicMock(), response=mock_resp,
+    )
+    mock_client = MagicMock()
+    mock_client.__enter__.return_value = mock_client
+    mock_client.__exit__.return_value = False
+    mock_client.get.return_value = mock_resp
+
+    env = {
+        "HOME": str(tmp_path),
+        "ALLOC_API_URL": "https://api.example.com",
+        "ALLOC_TOKEN": "stale-token",
+    }
+
+    with patch("httpx.Client", return_value=mock_client), \
+         patch("alloc.cli.try_refresh_access_token", return_value=None):
+        result = runner.invoke(app, ["whoami", "--json"], env=env)
+
+    assert result.exit_code == 0
+    data = json.loads(result.output)
+    assert data["logged_in"] is False
+    assert data["token_status"] == "expired"
+
+
 def test_whoami_logged_in_json(tmp_path: Path):
     profile_resp = MagicMock()
     profile_resp.raise_for_status.return_value = None
@@ -110,6 +138,7 @@ def test_whoami_logged_in_json(tmp_path: Path):
     assert result.exit_code == 0
     data = json.loads(result.output)
     assert data["logged_in"] is True
+    assert data["token_status"] == "valid"
     assert data["token_source"] == "env"
     assert data["email"] == "user@example.com"
     assert data["fleet_count"] == 1

{alloc-0.0.8 → alloc-0.0.9}/tests/test_topology_strategy.py

@@ -18,9 +18,15 @@ class TestStrategyInference:
                 num_gpus_detected=num_gpus,
             )
 
-    def test_no_degrees_strategy_none(self):
-        """When no degree env vars set, strategy should be None."""
-        result = self._topo({})
+    def test_no_degrees_multi_gpu_infers_ddp(self):
+        """When no degree env vars but multiple GPUs detected, infer DDP."""
+        result = self._topo({}, num_gpus=4)
+        assert result["strategy"] == "ddp"
+        assert result["dp_degree"] == 4
+
+    def test_single_gpu_no_degrees_strategy_none(self):
+        """Single GPU with no degrees → strategy stays None."""
+        result = self._topo({}, num_gpus=1)
         assert result["strategy"] is None
 
     def test_dp_only_is_ddp(self):