CLI bug fixes, improved help text, and test infrastructure

.github/workflows/ci.yml

@@ -0,0 +1,94 @@
+name: CI
+
+on:
+  push:
+    branches:
+      - master
+      - main
+  pull_request:
+    branches:
+      - master
+      - main
+
+jobs:
+  lint:
+    name: Lint (Ruff)
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      - name: Install Ruff
+        run: pip install ruff
+
+      - name: Run Ruff check
+        run: ruff check . --output-format=github
+
+      - name: Run Ruff format check
+        run: ruff format --check .
+
+  test:
+    name: Test (${{ matrix.os }} / Python ${{ matrix.python-version }})
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+        python-version: ["3.9", "3.10", "3.11", "3.12", "3.13"]
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+          cache: 'pip'
+
+      - name: Install dependencies
+        run: pip install -e ".[dev]"
+
+      - name: Run pytest with coverage
+        run: pytest --cov=vast --cov-report=xml
+
+      - name: Upload coverage to Codecov
+        if: matrix.os == 'ubuntu-latest' && matrix.python-version == '3.11'
+        uses: codecov/codecov-action@v4
+        with:
+          files: ./coverage.xml
+          fail_ci_if_error: false
+        env:
+          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+
+  smoke-standalone:
+    name: Smoke Test Standalone (${{ matrix.os }})
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      - name: Install minimal dependencies (standalone mode)
+        run: pip install requests python-dateutil
+
+      - name: Test vast.py --help
+        run: python vast.py --help
+
+      - name: Test vast.py search offers --help
+        run: python vast.py search offers --help
+
+      - name: Test vast.py show instances --help
+        run: python vast.py show instances --help

.gitignore

@@ -3,4 +3,17 @@ passed_machines.txt
 failed_machines.txt
 Pass_testresults.log
 dist/
+build/
 __pycache__/
+*.egg-info/
+*.egg
+.eggs/
+*.pyc
+*.pyo
+
+# Test artifacts
+.coverage
+.pytest_cache/
+
+# MkDocs build output
+site/

__init__.py

@@ -1 +1,4 @@
-from .vastai_sdk import VastAI
+try:
+    from .vastai_sdk import VastAI
+except ImportError:
+    pass

conftest.py

@@ -0,0 +1 @@
+collect_ignore = ["__init__.py", "vast.py", "vast_pdf.py", "vast_config.py"]

pyproject.toml

@@ -36,11 +36,22 @@ dependencies = [
   "cryptography (>=44.0.2,<45.0.0)",
   "rich",
   "fonttools>=4.60.2",
-  "qrcode"
+  "qrcode",
+]
+
+[project.optional-dependencies]
+dev = [
+  "pytest>=8.0",
+  "pytest-cov>=4.0",
+  "mypy>=1.14",
+  "types-requests>=2.32",
+  "types-python-dateutil>=2.9",
+  "ruff>=0.9",
+  "pre-commit>=4.0",
 ]
 
 [tool.poetry]
-packages = [{ include = "utils" }, { include = "vast.py" }]
+packages = [{ include = "utils" }, { include = "vast.py" }, { include = "vast_config.py" }]
 version = "0.0.0"
 
 [project.scripts]
@@ -58,3 +69,38 @@ style = "semver"
 
 [tool.poetry.requires-plugins]
 poetry-dynamic-versioning = { version = ">=1.0.0,<2.0.0", extras = ["plugin"] }
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.coverage.run]
+branch = true
+source = ["."]
+omit = ["*/tests/*", "*/.venv/*", "*/site-packages/*"]
+
+[tool.coverage.report]
+precision = 2
+show_missing = true
+
+[tool.ruff]
+line-length = 120
+target-version = "py310"
+exclude = [".git", ".venv", "__pycache__", "build", "dist", ".eggs", "*.egg-info"]
+
+[tool.ruff.lint]
+select = ["E", "W", "F", "I", "B", "C4", "UP"]
+ignore = ["E501"]
+
+[tool.ruff.lint.per-file-ignores]
+"vast.py" = ["T20", "A001", "A002", "E501", "B006", "F401", "F523", "F541", "F811", "F841", "E701", "E703", "E711", "E713", "E721", "E741"]
+"vast_pdf.py" = ["T20", "E501"]
+"tests/**/*.py" = ["F401", "S101"]
+
+[tool.ruff.lint.isort]
+known-first-party = ["vast"]
+
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"
+skip-magic-trailing-comma = false
+line-ending = "auto"

tests/conftest.py

@@ -0,0 +1,76 @@
+import json
+import os
+import pytest
+import argparse
+import requests
+from unittest.mock import MagicMock, patch
+
+
+@pytest.fixture
+def mock_args():
+    """Minimal argparse.Namespace for testing CLI functions."""
+    return argparse.Namespace(
+        api_key="test-key",
+        url="https://console.vast.ai",
+        retry=3,
+        raw=False,
+        explain=False,
+        quiet=False,
+        curl=False,
+        full=False,
+        no_color=True,
+        debugging=False,
+    )
+
+
+@pytest.fixture
+def mock_response():
+    """Mock HTTP response with configurable status and JSON body."""
+    response = MagicMock()
+    response.status_code = 200
+    response.json.return_value = {"success": True}
+    response.text = '{"success": true}'
+    response.content = b'{"success": true}'
+    response.headers = {"Content-Type": "application/json"}
+    response.raise_for_status = MagicMock()
+    return response
+
+
+@pytest.fixture
+def mock_api_response():
+    """Factory fixture for creating mock API responses with configurable status and data."""
+    def _make_response(status_code=200, json_data=None, text=None, headers=None):
+        response = MagicMock()
+        response.status_code = status_code
+        response.json.return_value = json_data if json_data is not None else {}
+        response.text = text if text is not None else json.dumps(json_data or {})
+        response.content = response.text.encode()
+        response.headers = headers if headers is not None else {"Content-Type": "application/json"}
+        if status_code >= 400:
+            response.raise_for_status.side_effect = requests.HTTPError(f"{status_code} Error")
+        else:
+            response.raise_for_status = MagicMock()
+        return response
+    return _make_response
+
+
+@pytest.fixture
+def mock_http_get(mock_api_response):
+    """Patch vast.http_get to return controlled responses."""
+    with patch('vast.http_get') as mock:
+        mock.return_value = mock_api_response(200, {"success": True})
+        yield mock
+
+
+@pytest.fixture
+def mock_http_post(mock_api_response):
+    """Patch vast.http_post to return controlled responses."""
+    with patch('vast.http_post') as mock:
+        mock.return_value = mock_api_response(200, {"success": True})
+        yield mock
+
+
+@pytest.fixture
+def vast_cli_path():
+    """Return path to vast.py for subprocess tests."""
+    return os.path.join(os.path.dirname(__file__), '..', 'vast.py')

tests/regression/test_bare_except.py

@@ -0,0 +1,102 @@
+"""No bare except: clauses in vast.py.
+
+The bug: Bare except: catches SystemExit and KeyboardInterrupt, which can
+mask critical errors and make the program unresponsive to Ctrl+C. It also
+swallows programming errors (NameError, TypeError) that should crash loudly.
+
+The fix: Replace all bare except: with specific exception types appropriate
+to each try block's expected failure modes.
+"""
+import sys
+import os
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..'))
+
+import re
+import pytest
+
+
+VAST_PY_PATH = os.path.join(os.path.dirname(__file__), '..', '..', 'vast.py')
+
+
+class TestNoBareExcept:
+    """Lint-style tests verifying no bare except: remains in vast.py."""
+
+    def test_no_bare_except(self):
+        """No bare except: clauses should exist in vast.py.
+
+        A bare except: catches everything including SystemExit and
+        KeyboardInterrupt, making Ctrl+C ineffective and masking bugs.
+        """
+        with open(VAST_PY_PATH, encoding='utf-8') as f:
+            content = f.read()
+        # Match "except:" but not "except SomeName:" or "except (A, B):"
+        bare_excepts = re.findall(r'^\s*except\s*:', content, re.MULTILINE)
+        assert len(bare_excepts) == 0, (
+            f"Found {len(bare_excepts)} bare except: clauses in vast.py. "
+            "Each except must catch specific exception types."
+        )
+
+    def test_except_clauses_have_types(self):
+        """Every except clause should specify at least one exception type."""
+        with open(VAST_PY_PATH, encoding='utf-8') as f:
+            content = f.read()
+        # Find all except lines
+        except_lines = re.findall(r'^\s*except\b.*:', content, re.MULTILINE)
+        for line in except_lines:
+            stripped = line.strip()
+            # Must be "except SomeType:" or "except (A, B) as e:" etc.
+            # NOT just "except:"
+            assert stripped != "except:", (
+                f"Found bare except: -- should catch specific types: {line!r}"
+            )
+
+
+class TestKeyboardInterruptPropagation:
+    """Verify KeyboardInterrupt is not swallowed by import handlers."""
+
+    def test_argcomplete_import_does_not_catch_keyboard_interrupt(self):
+        """The argcomplete import try/except should not catch KeyboardInterrupt.
+
+        Before the fix, bare except: would catch KeyboardInterrupt during
+        import, making Ctrl+C during startup silently ignored.
+        """
+        import importlib
+        import unittest.mock as mock
+
+        # Simulate argcomplete import raising KeyboardInterrupt
+        original_import = __builtins__.__import__ if hasattr(__builtins__, '__import__') else __import__
+
+        def mock_import(name, *args, **kwargs):
+            if name == 'argcomplete':
+                raise KeyboardInterrupt()
+            return original_import(name, *args, **kwargs)
+
+        # The except ImportError: handler should NOT catch KeyboardInterrupt
+        # so it should propagate
+        with pytest.raises(KeyboardInterrupt):
+            with mock.patch('builtins.__import__', side_effect=mock_import):
+                # Re-execute the import block logic
+                try:
+                    __import__('argcomplete')
+                except ImportError:
+                    pass  # This is what the fixed code does
+
+    def test_argcomplete_import_catches_import_error(self):
+        """The argcomplete import try/except should catch ImportError."""
+        import unittest.mock as mock
+
+        original_import = __builtins__.__import__ if hasattr(__builtins__, '__import__') else __import__
+
+        def mock_import(name, *args, **kwargs):
+            if name == 'argcomplete':
+                raise ImportError("No module named 'argcomplete'")
+            return original_import(name, *args, **kwargs)
+
+        # ImportError should be caught (not propagated)
+        caught = False
+        with mock.patch('builtins.__import__', side_effect=mock_import):
+            try:
+                __import__('argcomplete')
+            except ImportError:
+                caught = True
+        assert caught, "ImportError should be caught by except ImportError:"