nepher 0.1.0__py3-none-any.whl

nepher/cli/commands/auth.py

@@ -0,0 +1,37 @@
+"""Authentication commands."""
+
+import click
+from nepher.auth import login as auth_login, logout as auth_logout, whoami as auth_whoami
+from nepher.cli.utils import print_success, print_error, print_info
+
+
+@click.command()
+@click.argument("api_key")
+def login(api_key: str):
+    """Login with API key."""
+    if auth_login(api_key):
+        print_success("Login successful!")
+    else:
+        print_error("Login failed. Please check your API key.")
+
+
+@click.command()
+def logout():
+    """Logout and clear credentials."""
+    auth_logout()
+    print_success("Logged out successfully.")
+
+
+@click.command()
+def whoami():
+    """Show current user information."""
+    user_info = auth_whoami()
+    if user_info:
+        print_info("Current user:")
+        click.echo(f"  Fullname: {user_info.get('fullname', 'N/A')}")
+        click.echo(f"  Email: {user_info.get('email', 'N/A')}")
+        click.echo(f"  Role: {user_info.get('role', 'N/A')}")
+        click.echo(f"  Status: {user_info.get('status', 'N/A')}")
+    else:
+        print_error("Not authenticated. Use 'nepher login <api_key>' to authenticate.")
+

nepher/cli/commands/cache.py

@@ -0,0 +1,85 @@
+"""Cache management commands."""
+
+import click
+from pathlib import Path
+from typing import Optional
+from nepher.storage.cache import get_cache_manager
+from nepher.cli.utils import print_error, print_success, print_info
+
+
+@click.group()
+def cache():
+    """Manage local cache."""
+    pass
+
+
+@cache.command()
+def list():
+    """List cached environments."""
+    try:
+        cache_manager = get_cache_manager()
+        cached = cache_manager.list_cached()
+
+        if not cached:
+            print_info("No cached environments.")
+            return
+
+        print_info(f"Cached environments ({len(cached)}):")
+        for env_id in cached:
+            click.echo(f"  {env_id}")
+
+    except Exception as e:
+        print_error(f"Failed to list cache: {str(e)}")
+
+
+@cache.command()
+@click.argument("env_id", required=False)
+def clear(env_id: Optional[str]):
+    """Clear cache (all or specific environment)."""
+    try:
+        cache_manager = get_cache_manager()
+        if env_id:
+            cache_manager.clear_cache(env_id)
+            print_success(f"Cleared cache for {env_id}")
+        else:
+            cache_manager.clear_cache()
+            print_success("Cleared all cache")
+
+    except Exception as e:
+        print_error(f"Failed to clear cache: {str(e)}")
+
+
+@cache.command()
+def info():
+    """Show cache statistics."""
+    try:
+        cache_manager = get_cache_manager()
+        info = cache_manager.get_cache_info()
+
+        print_info("Cache Information:")
+        click.echo(f"  Cache Directory: {info['cache_dir']}")
+        click.echo(f"  Total Size: {info['total_size'] / (1024**2):.2f} MB")
+        click.echo(f"  Environment Count: {info['env_count']}")
+
+        if info["environments"]:
+            click.echo("\n  Environments:")
+            for env in info["environments"]:
+                click.echo(f"    {env['id']}: {env['size'] / (1024**2):.2f} MB")
+
+    except Exception as e:
+        print_error(f"Failed to get cache info: {str(e)}")
+
+
+@cache.command()
+@click.argument("new_path", type=click.Path())
+def migrate(new_path: str):
+    """Migrate cache to new location."""
+    try:
+        cache_manager = get_cache_manager()
+        new_cache_dir = Path(new_path)
+        cache_manager.migrate_cache(new_cache_dir)
+        print_success(f"Cache migrated to {new_path}")
+
+    except Exception as e:
+        print_error(f"Failed to migrate cache: {str(e)}")
+

nepher/cli/commands/config.py

@@ -0,0 +1,77 @@
+"""Configuration management commands."""
+
+import click
+from nepher.config import get_config, set_config
+from nepher.cli.utils import print_error, print_success, print_info
+
+
+@click.group()
+def config():
+    """Manage configuration."""
+    pass
+
+
+@config.command()
+@click.argument("key")
+def get(key: str):
+    """Get configuration value."""
+    try:
+        value = get_config().get(key)
+        if value is None:
+            print_error(f"Configuration key '{key}' not found.")
+        else:
+            click.echo(value)
+
+    except Exception as e:
+        print_error(f"Failed to get config: {str(e)}")
+
+
+@config.command()
+@click.argument("key")
+@click.argument("value")
+def set(key: str, value: str):
+    """Set configuration value."""
+    try:
+        if value.lower() in ("true", "false"):
+            value = value.lower() == "true"
+        elif value.isdigit():
+            value = int(value)
+        elif value.replace(".", "", 1).isdigit():
+            value = float(value)
+
+        set_config(key, value, save=True)
+        print_success(f"Set {key} = {value}")
+
+    except Exception as e:
+        print_error(f"Failed to set config: {str(e)}")
+
+
+@config.command()
+def list():
+    """List all configuration values."""
+    try:
+        cfg = get_config()
+        print_info("Configuration:")
+        click.echo(f"  api_url: {cfg.get('api_url')}")
+        click.echo(f"  cache_dir: {cfg.get('cache_dir')}")
+        click.echo(f"  default_category: {cfg.get('default_category')}")
+
+    except Exception as e:
+        print_error(f"Failed to list config: {str(e)}")
+
+
+@config.command()
+def reset():
+    """Reset configuration to defaults."""
+    try:
+        config = get_config()
+        config_file = getattr(config, "_config_file", None)
+        if config_file and config_file.exists():
+            config_file.unlink()
+            print_success("Configuration reset to defaults.")
+        else:
+            print_info("No configuration file to reset.")
+
+    except Exception as e:
+        print_error(f"Failed to reset config: {str(e)}")
+

nepher/cli/commands/download.py

@@ -0,0 +1,72 @@
+"""Download environment command."""
+
+from pathlib import Path
+from typing import Optional
+import click
+from nepher.api.client import get_client
+from nepher.storage.cache import get_cache_manager
+from nepher.storage.bundle import BundleManager
+from nepher.cli.utils import print_error, print_success, print_info
+
+
+@click.command()
+@click.argument("env_id")
+@click.option("--category", required=True, help="Environment category")
+@click.option("--cache-dir", type=click.Path(), help="Override cache directory")
+@click.option("--force", is_flag=True, help="Force re-download")
+def download(env_id: str, category: str, cache_dir: Optional[str], force: bool):
+    """Download an environment."""
+    try:
+        client = get_client()
+        cache_manager = get_cache_manager(
+            cache_dir=Path(cache_dir) if cache_dir else None, category=category
+        )
+
+        actual_env_id = env_id
+        try:
+            env_info = client.get_environment(env_id)
+            actual_env_id = env_info.get("id", env_id)
+        except Exception:
+            print_info(f"Searching for environment matching '{env_id}'...")
+            envs = client.list_environments(category=category, search=env_id, limit=10)
+            
+            matches = [e for e in envs if e.get("original_name") == env_id]
+            
+            if not matches:
+                matches = [e for e in envs if env_id.lower() in e.get("original_name", "").lower()]
+            
+            if not matches:
+                print_error(f"Environment '{env_id}' not found in category '{category}'")
+                print_info("Use 'nepher list --category navigation' to see available environments")
+                return
+            
+            if len(matches) > 1:
+                matches.sort(key=lambda x: x.get("uploaded_at", ""), reverse=True)
+                print_info(f"Found {len(matches)} matches, using most recent: {matches[0].get('id')}")
+            
+            actual_env_id = matches[0].get("id")
+            if not actual_env_id:
+                print_error(f"Could not determine environment ID for '{env_id}'")
+                return
+
+        if cache_manager.is_cached(actual_env_id) and not force:
+            print_info(f"Environment {actual_env_id} is already cached.")
+            return
+
+        print_info(f"Downloading {actual_env_id}...")
+
+        cache_path = cache_manager.get_env_cache_path(actual_env_id)
+        zip_path = cache_path.parent / f"{actual_env_id}.zip"
+
+        client.download_environment(actual_env_id, zip_path)
+
+        print_info("Extracting bundle...")
+        BundleManager.extract_bundle(zip_path, cache_path)
+
+        zip_path.unlink()
+
+        print_success(f"Environment {actual_env_id} downloaded and cached successfully!")
+
+    except Exception as e:
+        print_error(f"Failed to download environment: {str(e)}")
+

nepher/cli/commands/list.py

@@ -0,0 +1,75 @@
+"""List environments command."""
+
+import json
+from typing import Optional
+import click
+from nepher.api.client import get_client
+from nepher.cli.utils import print_error, print_info
+
+
+@click.command(name="list")
+@click.option("--category", help="Filter by category")
+@click.option("--type", type=click.Choice(["usd", "preset"]), help="Filter by type")
+@click.option("--benchmark", is_flag=True, help="List only benchmark environments")
+@click.option("--eval-benchmarks", "eval_benchmarks", is_flag=True, help="List only evaluation benchmarks")
+@click.option("--search", help="Search query")
+@click.option("--json", "output_json", is_flag=True, help="Output as JSON")
+@click.option("--limit", type=int, help="Maximum number of results")
+def list_cmd(
+    category: Optional[str],
+    type: Optional[str],
+    benchmark: bool,
+    eval_benchmarks: bool,
+    search: Optional[str],
+    output_json: bool,
+    limit: Optional[int],
+):
+    """List available environments."""
+    try:
+        client = get_client()
+        
+        if eval_benchmarks:
+            envs = client.list_eval_benchmarks()
+        else:
+            envs = client.list_environments(
+                category=category,
+                type=type,
+                benchmark=benchmark if benchmark else None,
+                search=search,
+                limit=limit,
+            )
+
+        if output_json:
+            click.echo(json.dumps(envs, indent=2))
+        else:
+            if not envs:
+                print_info("No environments found.")
+                return
+
+            print_info(f"Found {len(envs)} environment(s):\n")
+            for env in envs:
+                click.echo(f"  {env.get('id', 'N/A')}")
+                click.echo(f"    Name: {env.get('original_name', 'N/A')}")
+                click.echo(f"    Version: {env.get('version', 'N/A')}")
+                click.echo(f"    Category: {env.get('category', 'N/A')}")
+                click.echo(f"    Type: {env.get('type', 'N/A')}")
+                click.echo(f"    Status: {env.get('status', 'N/A')}")
+
+                if env.get("is_benchmark"):
+                    click.echo("    Benchmark: Yes")
+
+                if eval_benchmarks:
+                    if env.get("evaluation_period_start"):
+                        click.echo(f"    Evaluation Start: {env.get('evaluation_period_start')}")
+                    if env.get("evaluation_period_end"):
+                        click.echo(f"    Evaluation End: {env.get('evaluation_period_end')}")
+                    if env.get("is_active_for_evaluation") is not None:
+                        click.echo(f"    Active for Evaluation: {'Yes' if env.get('is_active_for_evaluation') else 'No'}")
+                
+                if env.get("description"):
+                    click.echo(f"    Description: {env.get('description')}")
+                click.echo()
+
+    except Exception as e:
+        print_error(f"Failed to list environments: {str(e)}")
+

nepher/cli/commands/upload.py

@@ -0,0 +1,69 @@
+"""Upload environment command."""
+
+import shutil
+import tempfile
+import zipfile
+from pathlib import Path
+from typing import Optional
+import click
+from nepher.api.client import get_client
+from nepher.storage.bundle import BundleManager
+from nepher.cli.utils import print_error, print_success, print_info
+
+
+@click.command()
+@click.argument("path", type=click.Path(exists=True))
+@click.option("--category", required=True, help="Environment category")
+@click.option("--benchmark", is_flag=True, help="Mark as benchmark environment")
+@click.option("--force", is_flag=True, help="Force upload even if duplicate exists")
+@click.option("--thumbnail", type=click.Path(exists=True), help="Thumbnail image path")
+def upload(path: str, category: str, benchmark: bool, force: bool, thumbnail: Optional[str]):
+    """Upload an environment bundle."""
+    temp_zip = None
+    try:
+        bundle_path = Path(path)
+        if not bundle_path.exists():
+            print_error(f"Bundle not found: {bundle_path}")
+            return
+
+        print_info("Validating bundle...")
+        if not BundleManager.validate_bundle(bundle_path):
+            print_error("Invalid bundle: manifest.yaml not found")
+            return
+
+        upload_path = bundle_path
+        if bundle_path.is_dir():
+            print_info("Creating bundle ZIP...")
+            temp_dir = tempfile.gettempdir()
+            zip_name = f"{bundle_path.name}.zip"
+            temp_zip = Path(temp_dir) / zip_name
+            
+            with zipfile.ZipFile(temp_zip, "w", zipfile.ZIP_DEFLATED) as zipf:
+                for file_path in bundle_path.rglob("*"):
+                    if file_path.is_file():
+                        arcname = file_path.relative_to(bundle_path)
+                        zipf.write(file_path, arcname)
+            
+            upload_path = temp_zip
+
+        print_info(f"Uploading {bundle_path.name}...")
+
+        client = get_client()
+        result = client.upload_environment(
+            bundle_path=upload_path,
+            category=category,
+            benchmark=benchmark,
+            force=force,
+            duplicate_policy="reject",
+            thumbnail=Path(thumbnail) if thumbnail else None,
+        )
+
+        print_success(f"Environment uploaded successfully!")
+        click.echo(f"  Environment ID: {result.get('id', 'N/A')}")
+
+    except Exception as e:
+        print_error(f"Failed to upload environment: {str(e)}")
+    finally:
+        if temp_zip and temp_zip.exists():
+            temp_zip.unlink()
+