vantage-cli 0.1.4__tar.gz → 0.1.5__tar.gz

{vantage_cli-0.1.4 → vantage_cli-0.1.5}/.github/workflows/ci.yml

@@ -46,4 +46,4 @@ jobs:
       - name: Run unit tests
         run: just unit
       - name: Run integration tests
-        run: just integration
+        run: just integration

vantage_cli-0.1.5/.github/workflows/pages.yml

@@ -0,0 +1,58 @@
+name: Deploy Docs
+
+on:
+  push:
+    branches: ["main"]
+
+  workflow_dispatch:
+
+concurrency:
+  group: "pages"
+  cancel-in-progress: false
+
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+
+jobs:
+  build:
+    name: Build Docusaurus
+    runs-on: ubuntu-24.04
+
+    # Deploy to the github-pages environment
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 22
+          cache: yarn
+          cache-dependency-path: docs/yarn.lock
+
+      - name: Install just
+        run: sudo snap install just --classic
+
+      - name: Install UV
+        run: sudo snap install astral-uv --classic
+
+      - name: Build website
+        run: just docs-build
+
+      - name: Setup Pages
+        uses: actions/configure-pages@v5
+
+      - name: Upload artifact
+        uses: actions/upload-pages-artifact@v3
+        with:
+          # Upload entire repository
+          path: './docs/build'
+
+      - name: Deploy to GitHub Pages
+        id: deployment
+        uses: actions/deploy-pages@v4

vantage_cli-0.1.5/.gitignore

@@ -0,0 +1,66 @@
+__pycache__/
+**/__pycache__/
+**/**/__pycache__/
+
+# Docusaurus
+docs/node_modules
+docs/yarn-global
+docs/yarn-cache
+docs/.docusaurus
+docs/build
+docs/.yarn
+docs/yarn-error.log
+docs/npm-debug.log*
+docs/yarn-debug.log*
+
+
+# Python virtual environments
+.venv
+venv/
+env/
+.env
+**/.env
+
+# Coverage reports
+.coverage
+cover_unit
+cover_integration
+cover_combined
+.coverage.*
+coverage
+cover/
+htmlcov/
+
+# Testing and linting
+.tox/
+.nox/
+.pytest_cache/
+.pytest_cache/**
+.pytest_cache/**/*
+.pytest_cache/**/*
+.ruff_cache/
+.mypy_cache/
+.dmypy.json
+.dmypy.json/**
+.pyre/
+.pyre/**
+.pyre/**/*
+
+# Jupyter
+.ipynb_checkpoints
+
+# IDE and editor files
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS generated files
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db

{vantage_cli-0.1.4 → vantage_cli-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vantage-cli
-Version: 0.1.4
+Version: 0.1.5
 Summary: The Vantage Compute CLI.
 Author-email: jamesbeedy <james@vantagecompute.ai>
 License: MIT

vantage_cli-0.1.5/debug_annotations.py

@@ -0,0 +1,38 @@
+#!/usr/bin/env python3
+"""Debug script to check if JsonOption annotation is the issue."""
+
+import inspect
+import typer
+import functools
+from typing_extensions import Annotated
+
+JsonOption = Annotated[bool, typer.Option("--json", "-j", help="Output in JSON format")]
+
+def test_wrapper1(ctx: typer.Context, json_output: bool = False):
+    """Wrapper with plain bool type."""
+    return "test"
+
+def test_wrapper2(ctx: typer.Context, json_output: JsonOption = False):
+    """Wrapper with JsonOption type.""" 
+    return "test"
+
+print("test_wrapper1 signature (plain bool):")
+print(inspect.signature(test_wrapper1))
+
+print("\ntest_wrapper2 signature (JsonOption):")
+print(inspect.signature(test_wrapper2))
+
+# Test parameter inspection
+sig1 = inspect.signature(test_wrapper1)
+sig2 = inspect.signature(test_wrapper2)
+
+print(f"\ntest_wrapper1 parameters: {list(sig1.parameters.keys())}")
+print(f"test_wrapper2 parameters: {list(sig2.parameters.keys())}")
+
+print(f"\njson_output param in wrapper1: {'json_output' in sig1.parameters}")
+print(f"json_output param in wrapper2: {'json_output' in sig2.parameters}")
+
+if 'json_output' in sig2.parameters:
+    param = sig2.parameters['json_output']
+    print(f"json_output annotation: {param.annotation}")
+    print(f"json_output default: {param.default}")

vantage_cli-0.1.5/debug_decorators.py

@@ -0,0 +1,46 @@
+#!/usr/bin/env python3
+"""Debug script to understand how the decorators work."""
+
+import inspect
+import typer
+from vantage_cli.decorators import vantage_command, JsonOption
+
+app = typer.Typer()
+
+# Test the decorator manually
+def test_func(ctx: typer.Context):
+    return "test"
+
+print("Original function signature:")
+print(inspect.signature(test_func))
+
+# Apply the decorator manually to see what happens
+decorator = vantage_command(app, "test")
+wrapped = decorator(test_func)
+
+print("\nAfter applying vantage_command:")
+print(f"wrapped is: {wrapped}")
+print(f"wrapped type: {type(wrapped)}")
+print(f"wrapped signature: {inspect.signature(wrapped)}")
+
+print(f"\nRegistered commands: {len(app.registered_commands)}")
+if app.registered_commands:
+    cmd = app.registered_commands[0]
+    print(f"Command name: {cmd.name}")
+    print(f"Command callback: {cmd.callback}")
+    print(f"Command callback type: {type(cmd.callback)}")
+    if cmd.callback:
+        print(f"Command callback signature: {inspect.signature(cmd.callback)}")
+
+# Let's also test what the wrapper function looks like in isolation
+import functools
+
+def manual_wrapper(func):
+    @functools.wraps(func)
+    def wrapper(ctx: typer.Context, *args, json_output: JsonOption = False, **kwargs):
+        print(f"Wrapper called with json_output={json_output}")
+        return func(ctx, *args, **kwargs)
+    return wrapper
+
+wrapped_manual = manual_wrapper(test_func)
+print(f"\nManual wrapper signature: {inspect.signature(wrapped_manual)}")

vantage_cli-0.1.5/debug_typer.py

@@ -0,0 +1,41 @@
+#!/usr/bin/env python3
+"""Debug script to understand how typer.command works."""
+
+import inspect
+import typer
+import functools
+from typing_extensions import Annotated
+
+app = typer.Typer()
+
+JsonOption = Annotated[bool, typer.Option("--json", "-j", help="Output in JSON format")]
+
+def original_func(ctx: typer.Context):
+    return "original"
+
+print("Original function signature:")
+print(inspect.signature(original_func))
+
+# Create a wrapper manually  
+@functools.wraps(original_func)
+def wrapper(ctx: typer.Context, *args, json_output: JsonOption = False, **kwargs):
+    return original_func(ctx, *args, **kwargs)
+
+print(f"\nWrapper signature: {inspect.signature(wrapper)}")
+
+# Test what app.command returns
+result = app.command("test")(wrapper)
+
+print(f"\napp.command result: {result}")
+print(f"result is wrapper: {result is wrapper}")
+print(f"result is original_func: {result is original_func}")
+print(f"result signature: {inspect.signature(result)}")
+
+# Check what's registered
+print(f"\nRegistered commands: {len(app.registered_commands)}")
+if app.registered_commands:
+    cmd = app.registered_commands[0]
+    print(f"Command callback: {cmd.callback}")
+    print(f"Callback is wrapper: {cmd.callback is wrapper}")
+    print(f"Callback is result: {cmd.callback is result}")
+    print(f"Callback signature: {inspect.signature(cmd.callback)}")

vantage_cli-0.1.5/debug_wraps.py

@@ -0,0 +1,57 @@
+#!/usr/bin/env python3
+"""Debug script to test functools.wraps behavior."""
+
+import inspect
+import typer
+import functools
+from typing_extensions import Annotated
+
+JsonOption = Annotated[bool, typer.Option("--json", "-j", help="Output in JSON format")]
+
+def original_func(ctx: typer.Context):
+    """Original function."""
+    return "original"
+
+print("Original function signature:")
+print(inspect.signature(original_func))
+
+# Test wrapper WITHOUT functools.wraps
+def wrapper_no_wraps(ctx: typer.Context, json_output: JsonOption = False):
+    """Wrapper without functools.wraps."""
+    return original_func(ctx)
+
+print(f"\nWrapper without @functools.wraps signature:")
+print(inspect.signature(wrapper_no_wraps))
+
+# Test wrapper WITH functools.wraps
+@functools.wraps(original_func)
+def wrapper_with_wraps(ctx: typer.Context, json_output: JsonOption = False):
+    """Wrapper with functools.wraps."""
+    return original_func(ctx)
+
+print(f"\nWrapper with @functools.wraps signature:")
+print(inspect.signature(wrapper_with_wraps))
+
+print(f"\nWrapper without wraps parameters: {list(inspect.signature(wrapper_no_wraps).parameters.keys())}")
+print(f"Wrapper with wraps parameters: {list(inspect.signature(wrapper_with_wraps).parameters.keys())}")
+
+# Check what __wrapped__ attribute contains
+if hasattr(wrapper_with_wraps, '__wrapped__'):
+    print(f"\n__wrapped__ signature: {inspect.signature(wrapper_with_wraps.__wrapped__)}")
+    
+# Test manually setting signature
+wrapper_manual = lambda ctx, json_output=False: original_func(ctx)
+wrapper_manual.__name__ = original_func.__name__
+wrapper_manual.__doc__ = original_func.__doc__
+
+print(f"\nManual wrapper (before signature): {inspect.signature(wrapper_manual)}")
+
+# Manually set the signature
+from inspect import Parameter, Signature
+params = [
+    Parameter('ctx', Parameter.POSITIONAL_OR_KEYWORD, annotation=typer.Context),
+    Parameter('json_output', Parameter.KEYWORD_ONLY, default=False, annotation=JsonOption)
+]
+wrapper_manual.__signature__ = Signature(params)
+
+print(f"Manual wrapper (after signature): {inspect.signature(wrapper_manual)}")

vantage_cli-0.1.5/fix_cluster_tests.py

@@ -0,0 +1,57 @@
+#!/usr/bin/env python3
+"""Script to fix cluster tests by applying json_output parameter removal pattern."""
+
+import re
+
+def fix_cluster_tests():
+    file_path = "tests/unit/test_cluster_commands.py"
+    
+    with open(file_path, 'r') as f:
+        content = f.read()
+    
+    # Add SimpleNamespace import if not present
+    if "from types import SimpleNamespace" not in content:
+        content = content.replace(
+            "from unittest.mock import Mock, patch",
+            "from types import SimpleNamespace\nfrom unittest.mock import Mock, patch"
+        )
+    
+    # Fix mock_context fixtures
+    fixture_pattern = r'(ctx\.obj = Mock\(\)\s+ctx\.obj\.settings = Mock\(\)\s+ctx\.obj\.profile = "default")'
+    fixture_replacement = 'ctx.obj = SimpleNamespace(\n            profile="default",\n            verbose=False,\n            json_output=False\n        )'
+    
+    content = re.sub(fixture_pattern, fixture_replacement, content, flags=re.MULTILINE)
+    
+    # Fix function calls - remove json_output parameters
+    patterns_to_fix = [
+        (r'list_clusters\(([^,]+), json_output=\w+\)', r'list_clusters(\1)'),
+        (r'delete_cluster\(([^,]+), ([^,]+), force=(\w+), json_output=\w+\)', r'delete_cluster(\1, \2, force=\3)'),
+        (r'get_cluster\(([^,]+), ([^,]+), json_output=\w+\)', r'get_cluster(\1, \2)'),
+    ]
+    
+    for pattern, replacement in patterns_to_fix:
+        content = re.sub(pattern, replacement, content)
+    
+    # Add context setting before function calls for json_output tests
+    content = re.sub(
+        r'(mock_get_effective_json_output\.return_value = True)\s+(# Call the function)',
+        r'\1\n        mock_ctx.obj.json_output = True\n        \2',
+        content,
+        flags=re.MULTILINE
+    )
+    
+    # Handle cases where json_output is False
+    content = re.sub(
+        r'(await list_clusters\(mock_ctx\))\s+(# Check that render_json was called)',
+        r'mock_ctx.obj.json_output = True\n        \1\n        \2',
+        content,
+        flags=re.MULTILINE
+    )
+    
+    with open(file_path, 'w') as f:
+        f.write(content)
+    
+    print("Cluster tests fixed!")
+
+if __name__ == "__main__":
+    fix_cluster_tests()

vantage_cli-0.1.5/fix_config_tests.py

@@ -0,0 +1,51 @@
+#!/usr/bin/env python3
+"""Script to fix config tests by applying json_output parameter removal pattern."""
+
+import re
+
+def fix_config_tests():
+    file_path = "tests/unit/test_config_commands.py"
+    
+    with open(file_path, 'r') as f:
+        content = f.read()
+    
+    # Add SimpleNamespace import if not present
+    if "from types import SimpleNamespace" not in content:
+        content = content.replace(
+            "from unittest.mock import AsyncMock, Mock, patch",
+            "from types import SimpleNamespace\nfrom unittest.mock import AsyncMock, Mock, patch"
+        )
+    
+    # Fix mock_context fixtures - replace Mock objects with SimpleNamespace
+    fixture_pattern = r'(ctx\.obj = Mock\(\)[^}]+ctx\.obj\.profile = "default"[^}]*return ctx)'
+    fixture_replacement = '''ctx.obj = SimpleNamespace(
+            profile="default",
+            verbose=False,
+            json_output=False
+        )
+        return ctx'''
+    
+    content = re.sub(fixture_pattern, fixture_replacement, content, flags=re.MULTILINE | re.DOTALL)
+    
+    # Fix function calls - remove json_output parameters and add context setting
+    patterns_to_fix = [
+        (r'(await clear_config\([^,]+), json_output=(\w+)\)', r'mock_ctx.obj.json_output = \2\n        \1)'),
+    ]
+    
+    for pattern, replacement in patterns_to_fix:
+        content = re.sub(pattern, replacement, content)
+    
+    # Also fix any direct call patterns
+    content = re.sub(
+        r'await clear_config\(([^,]+), force=(\w+), json_output=(\w+)\)',
+        r'mock_ctx.obj.json_output = \3\n        await clear_config(\1, force=\2)',
+        content
+    )
+    
+    with open(file_path, 'w') as f:
+        f.write(content)
+    
+    print("Config tests fixed!")
+
+if __name__ == "__main__":
+    fix_config_tests()

vantage_cli-0.1.5/fix_federation_tests.py

@@ -0,0 +1,47 @@
+#!/usr/bin/env python3
+"""Script to fix federation tests by applying json_output parameter removal pattern."""
+
+import re
+
+def fix_federation_tests():
+    file_path = "tests/unit/test_federation_commands.py"
+    
+    with open(file_path, 'r') as f:
+        content = f.read()
+    
+    # Fix mock_context fixtures
+    fixture_pattern = r'(ctx\.obj = Mock\(\)\s+ctx\.obj\.settings = Mock\(\)\s+ctx\.obj\.profile = "default")'
+    fixture_replacement = 'ctx.obj = SimpleNamespace(\n            profile="default",\n            verbose=False,\n            json_output=False\n        )'
+    
+    content = re.sub(fixture_pattern, fixture_replacement, content, flags=re.MULTILINE)
+    
+    # Fix function calls - remove json_output parameters
+    patterns_to_fix = [
+        (r'list_federations\(([^,]+), json_output=\w+\)', r'list_federations(\1)'),
+        (r'create_federation\(([^,]+), ([^,]+), ([^,]+), json_output=\w+\)', r'create_federation(\1, \2, \3)'),
+        (r'delete_federation\(([^,]+), ([^,]+), force=(\w+), json_output=\w+\)', r'delete_federation(\1, \2, force=\3)'),
+        (r'get_federation\(([^,]+), ([^,]+), json_output=\w+\)', r'get_federation(\1, \2)'),
+        (r'update_federation\(([^,]+), ([^,]+), json_output=\w+\)', r'update_federation(\1, \2)'),
+    ]
+    
+    for pattern, replacement in patterns_to_fix:
+        content = re.sub(pattern, replacement, content)
+    
+    # Add context setting before function calls
+    json_output_patterns = [
+        (r'(mock_get_json_output\.return_value = True)\s+# Run the command\s+import asyncio\s+(asyncio\.run\(list_federations\(mock_context\)\))', 
+         r'\1\n        mock_context.obj.json_output = True\n        # Run the command\n        import asyncio\n        \2'),
+        (r'(mock_get_json_output\.return_value = False)\s+mock_console = Mock\(\)\s+mock_console_class\.return_value = mock_console\s+# Run the command\s+import asyncio\s+(asyncio\.run\(list_federations\(mock_context\)\))',
+         r'\1\n        mock_console = Mock()\n        mock_console_class.return_value = mock_console\n        mock_context.obj.json_output = False\n        # Run the command\n        import asyncio\n        \2'),
+    ]
+    
+    for pattern, replacement in json_output_patterns:
+        content = re.sub(pattern, replacement, content, flags=re.MULTILINE | re.DOTALL)
+    
+    with open(file_path, 'w') as f:
+        f.write(content)
+    
+    print("Federation tests fixed!")
+
+if __name__ == "__main__":
+    fix_federation_tests()

vantage_cli-0.1.5/fix_profile_crud.py

@@ -0,0 +1,86 @@
+#!/usr/bin/env python3
+"""Fix profile CRUD tests by removing json_output parameters and updating context setup."""
+
+import re
+
+def fix_profile_crud_tests():
+    # Read the file
+    with open('tests/unit/test_profile_crud.py', 'r') as f:
+        content = f.read()
+    
+    # Pattern 1: Remove json_output=True/False from function calls
+    # create_profile(ctx=mock_ctx, profile_name="test_profile", json_output=True)
+    content = re.sub(
+        r'(create_profile\([^)]*), json_output=[^)]*\)',
+        r'\1)',
+        content
+    )
+    
+    # delete_profile(ctx=mock_ctx, profile_name="nonexistent", json_output=False)
+    content = re.sub(
+        r'(delete_profile\([^)]*), json_output=[^)]*\)',
+        r'\1)',
+        content
+    )
+    
+    # get_profile(ctx=mock_ctx, profile_name="test_profile", json_output=True)
+    content = re.sub(
+        r'(get_profile\([^)]*), json_output=[^)]*\)',
+        r'\1)',
+        content
+    )
+    
+    # list_profiles(ctx=mock_ctx, json_output=True)
+    content = re.sub(
+        r'(list_profiles\([^)]*), json_output=[^)]*\)',
+        r'\1)',
+        content
+    )
+    
+    # use_profile(ctx=mock_ctx, profile_name="test_profile", json_output=True)
+    content = re.sub(
+        r'(use_profile\([^)]*), json_output=[^)]*\)',
+        r'\1)',
+        content
+    )
+    
+    # Pattern 2: Handle multiline function calls with json_output
+    # For create_profile with multiple parameters including json_output
+    content = re.sub(
+        r'(create_profile\([\s\S]*?),\s*json_output=[^,)]*\s*\)',
+        r'\1)',
+        content
+    )
+    
+    # Pattern 3: Update mock_ctx = MagicMock() to include SimpleNamespace setup
+    # Look for test methods that don't already have the obj setup
+    def update_mock_ctx(match):
+        method_content = match.group(0)
+        # Check if SimpleNamespace is already set up
+        if 'mock_ctx.obj = SimpleNamespace' in method_content:
+            return method_content
+        
+        # Find the mock_ctx = MagicMock() line and add the obj setup after it
+        method_content = re.sub(
+            r'(mock_ctx = MagicMock\(\))',
+            r'\1\n        mock_ctx.obj = SimpleNamespace(profile="default", verbose=False, json_output=True)',
+            method_content
+        )
+        return method_content
+    
+    # Apply to all test methods
+    content = re.sub(
+        r'(def test_[^:]*:.*?)(?=def|\Z)',
+        update_mock_ctx,
+        content,
+        flags=re.DOTALL
+    )
+    
+    # Write the file back
+    with open('tests/unit/test_profile_crud.py', 'w') as f:
+        f.write(content)
+    
+    print("Profile CRUD tests fixed!")
+
+if __name__ == '__main__':
+    fix_profile_crud_tests()

vantage_cli-0.1.5/fix_profile_crud_extra.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python3
+"""Fix profile CRUD extra tests by removing json_output parameters and updating context setup."""
+
+import re
+
+def fix_profile_crud_extra_tests():
+    # Read the file
+    with open('tests/unit/test_profile_crud_extra.py', 'r') as f:
+        content = f.read()
+    
+    # Add SimpleNamespace import
+    content = re.sub(
+        r'(from unittest.mock import MagicMock, patch)',
+        r'from types import SimpleNamespace\nfrom unittest.mock import MagicMock, patch',
+        content
+    )
+    
+    # Pattern 1: Remove json_output=True/False from function calls
+    content = re.sub(
+        r'(create_profile\([^)]*), json_output=[^)]*\)',
+        r'\1)',
+        content
+    )
+    
+    content = re.sub(
+        r'(delete_profile\([^)]*), json_output=[^)]*\)',
+        r'\1)',
+        content
+    )
+    
+    content = re.sub(
+        r'(get_profile\([^)]*), json_output=[^)]*\)',
+        r'\1)',
+        content
+    )
+    
+    content = re.sub(
+        r'(list_profiles\([^)]*), json_output=[^)]*\)',
+        r'\1)',
+        content
+    )
+    
+    content = re.sub(
+        r'(use_profile\([^)]*), json_output=[^)]*\)',
+        r'\1)',
+        content
+    )
+    
+    # Pattern 2: Handle multiline function calls with json_output
+    content = re.sub(
+        r'(create_profile\([\s\S]*?),\s*json_output=[^,)]*\s*\)',
+        r'\1)',
+        content
+    )
+    
+    content = re.sub(
+        r'(delete_profile\([\s\S]*?),\s*json_output=[^,)]*\s*\)',
+        r'\1)',
+        content
+    )
+    
+    content = re.sub(
+        r'(get_profile\([\s\S]*?),\s*json_output=[^,)]*\s*\)',
+        r'\1)',
+        content
+    )
+    
+    content = re.sub(
+        r'(list_profiles\([\s\S]*?),\s*json_output=[^,)]*\s*\)',
+        r'\1)',
+        content
+    )
+    
+    content = re.sub(
+        r'(use_profile\([\s\S]*?),\s*json_output=[^,)]*\s*\)',
+        r'\1)',
+        content
+    )
+    
+    # Pattern 3: Update mock_ctx = MagicMock() to include SimpleNamespace setup
+    def update_mock_ctx(match):
+        method_content = match.group(0)
+        # Check if SimpleNamespace is already set up
+        if 'mock_ctx.obj = SimpleNamespace' in method_content:
+            return method_content
+        
+        # Find the mock_ctx = MagicMock() line and add the obj setup after it
+        method_content = re.sub(
+            r'(mock_ctx = MagicMock\(\))',
+            r'\1\n    mock_ctx.obj = SimpleNamespace(profile="default", verbose=False, json_output=True)',
+            method_content
+        )
+        return method_content
+    
+    # Apply to all test functions
+    content = re.sub(
+        r'(def test_[^:]*:.*?)(?=def|\Z)',
+        update_mock_ctx,
+        content,
+        flags=re.DOTALL
+    )
+    
+    # Write the file back
+    with open('tests/unit/test_profile_crud_extra.py', 'w') as f:
+        f.write(content)
+    
+    print("Profile CRUD extra tests fixed!")
+
+if __name__ == '__main__':
+    fix_profile_crud_extra_tests()