modelstudio 0.6.1__tar.gz → 0.7.0__tar.gz

{modelstudio-0.6.1/python/modelstudio.egg-info → modelstudio-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modelstudio
-Version: 0.6.1
+Version: 0.7.0
 Summary: An early-stage AI tensor framework with CPU tensors, autograd, and backend extension scaffolding.
 Author: ModelStudio Contributors
 License-Expression: MIT
@@ -31,7 +31,7 @@ Dynamic: license-file
 
 # ModelStudio
 
-ModelStudio is an early-stage AI tensor framework. Version `0.6.1` provides a
+ModelStudio is an early-stage AI tensor framework. Version `0.7.0` provides a
 CPU tensor/autograd MVP with neural-network modules, optimizers, serialization,
 data loading, graph tracing metadata, backend status inspection, a public CUDA
 availability namespace, and small LLM-oriented building blocks.
@@ -242,6 +242,7 @@ python benchmarks/bench_cuda_elementwise.py
 python benchmarks/bench_cuda_matmul.py
 python benchmarks/bench_cuda_autograd.py
 python scripts/cuda_release_check.py
+python scripts/cuda_source_build_check.py
 ```
 
 ## Documentation

{modelstudio-0.6.1 → modelstudio-0.7.0}/README.md

@@ -1,6 +1,6 @@
 # ModelStudio
 
-ModelStudio is an early-stage AI tensor framework. Version `0.6.1` provides a
+ModelStudio is an early-stage AI tensor framework. Version `0.7.0` provides a
 CPU tensor/autograd MVP with neural-network modules, optimizers, serialization,
 data loading, graph tracing metadata, backend status inspection, a public CUDA
 availability namespace, and small LLM-oriented building blocks.
@@ -211,6 +211,7 @@ python benchmarks/bench_cuda_elementwise.py
 python benchmarks/bench_cuda_matmul.py
 python benchmarks/bench_cuda_autograd.py
 python scripts/cuda_release_check.py
+python scripts/cuda_source_build_check.py
 ```
 
 ## Documentation

{modelstudio-0.6.1 → modelstudio-0.7.0}/docs/backend-status.md

@@ -1,6 +1,6 @@
 # Backend Status
 
-ModelStudio 0.6.1 keeps CPU as the only available runtime backend in the
+ModelStudio 0.7.0 keeps CPU as the only available runtime backend in the
 default PyPI package. It also exposes a public CUDA status namespace so users
 can check accelerator availability without importing optional native artifacts.
 

{modelstudio-0.6.1 → modelstudio-0.7.0}/docs/cuda.md

@@ -1,6 +1,6 @@
 # CUDA Status
 
-ModelStudio 0.6.1 adds a public CUDA availability namespace and native scaffold,
+ModelStudio 0.7.0 includes a public CUDA availability namespace and native scaffold,
 but the default `modelstudio` PyPI package remains CPU-only.
 
 ```python
@@ -54,6 +54,18 @@ cmake -S . -B build-cuda -DMODELSTUDIO_ENABLE_CUDA=ON
 If the CUDA compiler or toolkit is missing, configuration fails clearly instead
 of silently producing a CPU-only build that looks CUDA-capable.
 
+On Windows source checkouts, the helper below bootstraps missing Python-side
+build tools such as the CMake wheel, runs CMake, and treats skipped CUDA tests
+as a failure:
+
+```powershell
+python scripts/cuda_source_build_check.py
+```
+
+If this fails with a C++ compiler or generator error, install Visual Studio
+Build Tools with the C++ workload and rerun it from a shell where `nvcc --version`
+works.
+
 ## Phase 7 Release Gate
 
 The next CUDA execution release must be prepared on a machine where all of
@@ -86,6 +98,12 @@ CPU-only machines may still run the same tests, but CUDA execution tests should
 skip with `CUDA unavailable`. That is useful development feedback, not release
 evidence for CUDA execution.
 
+For the same gate in one command from a source checkout:
+
+```bash
+python scripts/cuda_source_build_check.py
+```
+
 ## CUDA Examples And Benchmarks
 
 The CUDA scripts are safe to run on CPU-only installs:

{modelstudio-0.6.1 → modelstudio-0.7.0}/docs/native-backend-roadmap.md

@@ -1,6 +1,6 @@
 # Native Backend Roadmap
 
-The Python runtime still uses NumPy CPU kernels in 0.6.1. The native C++ tree is
+The Python runtime still uses NumPy CPU kernels in 0.7.0. The native C++ tree is
 scaffolding for future backend work and is intentionally not wired into Python
 dispatch yet.
 

{modelstudio-0.6.1 → modelstudio-0.7.0}/docs/releasing.md

@@ -55,6 +55,13 @@ python scripts/cuda_release_check.py
 On the CUDA release machine those tests must run and pass. If they skip because
 CUDA is unavailable, do not tag or publish the CUDA release.
 
+From a source checkout, this one-command gate also bootstraps missing
+Python-side build tools such as the CMake wheel and fails if CUDA tests skip:
+
+```bash
+python scripts/cuda_source_build_check.py
+```
+
 ## Build Distributions
 
 Start from clean build outputs:

{modelstudio-0.6.1 → modelstudio-0.7.0}/docs/training.md

@@ -1,6 +1,6 @@
 # Training
 
-ModelStudio 0.6.1 supports CPU training loops with modules, optimizers,
+ModelStudio 0.7.0 supports CPU training loops with modules, optimizers,
 loss functions, DataLoader batching, dropout, BatchNorm1d, and checkpointing.
 
 ```python

{modelstudio-0.6.1 → modelstudio-0.7.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "modelstudio"
-version = "0.6.1"
+version = "0.7.0"
 description = "An early-stage AI tensor framework with CPU tensors, autograd, and backend extension scaffolding."
 readme = "README.md"
 requires-python = ">=3.10"

modelstudio-0.7.0/python/modelstudio/_version.py

@@ -0,0 +1 @@
+__version__ = "0.7.0"

{modelstudio-0.6.1 → modelstudio-0.7.0/python/modelstudio.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modelstudio
-Version: 0.6.1
+Version: 0.7.0
 Summary: An early-stage AI tensor framework with CPU tensors, autograd, and backend extension scaffolding.
 Author: ModelStudio Contributors
 License-Expression: MIT
@@ -31,7 +31,7 @@ Dynamic: license-file
 
 # ModelStudio
 
-ModelStudio is an early-stage AI tensor framework. Version `0.6.1` provides a
+ModelStudio is an early-stage AI tensor framework. Version `0.7.0` provides a
 CPU tensor/autograd MVP with neural-network modules, optimizers, serialization,
 data loading, graph tracing metadata, backend status inspection, a public CUDA
 availability namespace, and small LLM-oriented building blocks.
@@ -242,6 +242,7 @@ python benchmarks/bench_cuda_elementwise.py
 python benchmarks/bench_cuda_matmul.py
 python benchmarks/bench_cuda_autograd.py
 python scripts/cuda_release_check.py
+python scripts/cuda_source_build_check.py
 ```
 
 ## Documentation

{modelstudio-0.6.1 → modelstudio-0.7.0}/python/modelstudio.egg-info/SOURCES.txt

@@ -166,6 +166,7 @@ python/modelstudio/runtime/dispatcher.py
 python/modelstudio/testing/__init__.py
 python/modelstudio/testing/gradcheck.py
 scripts/cuda_release_check.py
+scripts/cuda_source_build_check.py
 scripts/smoke_test.py
 tests/test_activations_more.py
 tests/test_attention.py

{modelstudio-0.6.1 → modelstudio-0.7.0}/scripts/cuda_release_check.py

@@ -5,8 +5,14 @@ import shutil
 import subprocess
 import sys
 from collections.abc import Sequence
+from pathlib import Path
 
-import modelstudio as ms
+_ROOT = Path(__file__).resolve().parents[1]
+_PYTHON_SRC = _ROOT / "python"
+if _PYTHON_SRC.exists():
+    sys.path.insert(0, str(_PYTHON_SRC))
+
+import modelstudio as ms  # noqa: E402
 
 
 def _run_probe(command: Sequence[str]) -> int:

modelstudio-0.7.0/scripts/cuda_source_build_check.py

@@ -0,0 +1,218 @@
+from __future__ import annotations
+
+import argparse
+import importlib.util
+import os
+import re
+import shutil
+import subprocess
+import sys
+import sysconfig
+from collections.abc import Sequence
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+DEFAULT_BUILD_DIR = ROOT / "build-cuda"
+CUDA_TESTS = [
+    "tests/test_cuda_availability.py",
+    "tests/test_cuda_tensor.py",
+    "tests/test_cuda_ops.py",
+    "tests/test_cuda_reductions.py",
+    "tests/test_cuda_matmul.py",
+    "tests/test_cuda_autograd.py",
+    "tests/test_cuda_optim.py",
+    "tests/test_cuda_nn.py",
+    "tests/test_cuda_memory.py",
+]
+
+
+class CheckFailed(RuntimeError):
+    """Raised when the CUDA source validation gate cannot complete."""
+
+
+def _scripts_dir() -> Path:
+    return Path(sysconfig.get_path("scripts"))
+
+
+def _command_name(name: str) -> str:
+    return f"{name}.exe" if os.name == "nt" else name
+
+
+def _resolve_command(name: str) -> str | None:
+    path_command = shutil.which(name)
+    if path_command is not None:
+        return path_command
+
+    scripts_command = _scripts_dir() / _command_name(name)
+    if scripts_command.exists():
+        return str(scripts_command)
+    return None
+
+
+def _format_command(command: Sequence[str | Path]) -> str:
+    return " ".join(str(part) for part in command)
+
+
+def _run(
+    command: Sequence[str | Path],
+    *,
+    cwd: Path = ROOT,
+    env: dict[str, str] | None = None,
+    capture: bool = False,
+) -> subprocess.CompletedProcess[str]:
+    print(f"$ {_format_command(command)}")
+    completed = subprocess.run(
+        [str(part) for part in command],
+        cwd=cwd,
+        env=env,
+        check=False,
+        text=True,
+        stdout=subprocess.PIPE if capture else None,
+        stderr=subprocess.STDOUT if capture else None,
+    )
+    if capture and completed.stdout:
+        print(completed.stdout.rstrip())
+    return completed
+
+
+def _require_command(command: str, hint: str) -> None:
+    resolved = _resolve_command(command)
+    if resolved is None:
+        raise CheckFailed(f"{command} was not found. {hint}")
+    probe_command = [resolved, "--version"] if command == "nvcc" else [resolved]
+    completed = _run(probe_command)
+    if completed.returncode != 0:
+        raise CheckFailed(f"{command} exists but returned exit code {completed.returncode}.")
+
+
+def _python_package_available(module_name: str) -> bool:
+    return importlib.util.find_spec(module_name) is not None
+
+
+def _bootstrap_build_tools(args: argparse.Namespace) -> None:
+    missing: list[str] = []
+    if _resolve_command("cmake") is None:
+        missing.append("cmake>=3.24")
+    if not _python_package_available("pytest"):
+        missing.append("pytest>=8")
+    if not _python_package_available("numpy"):
+        missing.append("numpy>=1.26")
+    if args.generator and args.generator.lower() == "ninja" and _resolve_command("ninja") is None:
+        missing.append("ninja")
+
+    if not missing:
+        return
+    if args.no_bootstrap:
+        raise CheckFailed(f"Missing build tools: {', '.join(missing)}")
+
+    print("Installing missing Python build tools into the active environment:")
+    completed = _run([sys.executable, "-m", "pip", "install", "-U", *missing])
+    if completed.returncode != 0:
+        raise CheckFailed("Failed to install missing Python build tools.")
+
+
+def _validation_env(build_dir: Path) -> dict[str, str]:
+    env = os.environ.copy()
+    existing_path = env.get("PATH", "")
+    env["PATH"] = os.pathsep.join([str(_scripts_dir()), existing_path]) if existing_path else str(_scripts_dir())
+
+    pythonpath_parts = [
+        ROOT / "python",
+        build_dir,
+        build_dir / "Release",
+        build_dir / "Debug",
+        build_dir / "csrc",
+        build_dir / "csrc" / "Release",
+        build_dir / "csrc" / "Debug",
+    ]
+    existing_pythonpath = env.get("PYTHONPATH")
+    if existing_pythonpath:
+        pythonpath_parts.append(Path(existing_pythonpath))
+    env["PYTHONPATH"] = os.pathsep.join(str(part) for part in pythonpath_parts)
+    return env
+
+
+def _configure_and_build(args: argparse.Namespace, cmake: str, env: dict[str, str]) -> None:
+    configure_command: list[str | Path] = [
+        cmake,
+        "-S",
+        ROOT,
+        "-B",
+        args.build_dir,
+        "-DMODELSTUDIO_ENABLE_CUDA=ON",
+    ]
+    if args.generator:
+        configure_command.extend(["-G", args.generator])
+
+    configure = _run(configure_command, env=env)
+    if configure.returncode != 0:
+        raise CheckFailed(
+            "CMake CUDA configure failed. On Windows, install CMake or let this script bootstrap it; "
+            "install Visual Studio Build Tools with the C++ workload; and run from a shell where nvcc works."
+        )
+
+    build = _run([cmake, "--build", args.build_dir, "--config", args.config], env=env)
+    if build.returncode != 0:
+        raise CheckFailed("CMake CUDA build failed.")
+
+
+def _run_cuda_tests(env: dict[str, str]) -> None:
+    completed = _run([sys.executable, "-m", "pytest", "-q", "-rs", *CUDA_TESTS], env=env, capture=True)
+    if completed.returncode != 0:
+        raise CheckFailed("CUDA pytest gate failed.")
+
+    output = completed.stdout or ""
+    skipped_match = re.search(r"(?P<count>\d+)\s+skipped", output, flags=re.IGNORECASE)
+    if skipped_match and int(skipped_match.group("count")) > 0:
+        raise CheckFailed(
+            "CUDA tests skipped. That means ModelStudio's Python runtime did not see an available CUDA backend."
+        )
+
+
+def _run_release_check(env: dict[str, str]) -> None:
+    completed = _run([sys.executable, "scripts/cuda_release_check.py"], env=env)
+    if completed.returncode != 0:
+        raise CheckFailed("Strict CUDA release check failed.")
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Validate a ModelStudio source checkout on a CUDA machine.")
+    parser.add_argument("--build-dir", type=Path, default=DEFAULT_BUILD_DIR)
+    parser.add_argument("--config", default="Release")
+    parser.add_argument("--generator", help="Optional CMake generator, for example Ninja.")
+    parser.add_argument("--no-bootstrap", action="store_true", help="Do not install missing Python build tools.")
+    parser.add_argument(
+        "--skip-cmake-build",
+        action="store_true",
+        help="Only run the Python CUDA tests and release check.",
+    )
+    return parser.parse_args()
+
+
+def main() -> int:
+    args = parse_args()
+    try:
+        print("ModelStudio CUDA source validation")
+        print("This validates real CUDA availability; skipped CUDA tests are treated as a failure.")
+        _require_command("nvidia-smi", "Install an NVIDIA driver and make sure nvidia-smi is on PATH.")
+        _require_command("nvcc", "Install the CUDA Toolkit and make sure nvcc is on PATH.")
+        _bootstrap_build_tools(args)
+        cmake = _resolve_command("cmake")
+        if cmake is None:
+            raise CheckFailed("cmake was not found after bootstrapping.")
+
+        env = _validation_env(args.build_dir)
+        if not args.skip_cmake_build:
+            _configure_and_build(args, cmake, env)
+        _run_cuda_tests(env)
+        _run_release_check(env)
+    except Exception as exc:  # noqa: BLE001
+        print(f"CUDA source validation failed: {exc}", file=sys.stderr)
+        return 1
+
+    print("CUDA source validation passed.")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

{modelstudio-0.6.1 → modelstudio-0.7.0}/tests/test_public_exports.py

@@ -23,5 +23,5 @@ def test_existing_public_names_remain_available():
     assert hasattr(ms, "numpy")
 
 
-def test_version_is_0_5_0():
-    assert ms.__version__ == "0.6.1"
+def test_version_is_current():
+    assert ms.__version__ == "0.7.0"

{modelstudio-0.6.1 → modelstudio-0.7.0}/tests/test_version.py

@@ -2,4 +2,4 @@ import modelstudio as ms
 
 
 def test_version_is_exported() -> None:
-    assert ms.__version__ == "0.6.1"
+    assert ms.__version__ == "0.7.0"

modelstudio-0.6.1/python/modelstudio/_version.py

@@ -1 +0,0 @@
-__version__ = "0.6.1"