leap-bundle 0.0.1a1__py3-none-any.whl

leap_bundle/__init__.py

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

leap_bundle/commands/auth.py

@@ -0,0 +1,112 @@
+"""Authentication commands for LEAP CLI."""
+
+import requests
+import typer
+from rich.console import Console
+
+from leap_bundle.utils.config import (
+    clear_api_token,
+    get_api_token,
+    get_server_url,
+    is_logged_in,
+    set_api_token,
+)
+
+console = Console()
+app = typer.Typer()
+
+
+def validate_api_token(token: str) -> bool:
+    """Validate API token with the LEAP platform."""
+    try:
+        server_url = get_server_url()
+        api_url = f"{server_url.rstrip('/')}/api/cli/login"
+        response = requests.post(api_url, json={"api_token": token}, timeout=10)
+        return response.status_code == 200
+    except requests.RequestException as e:
+        console.print(f"[red]✗[/red] Failed to validate API token: {e}")
+        return False
+
+
+@app.command("login")
+def login(
+    api_token: str = typer.Argument(..., help="API token for LEAP platform"),
+) -> None:
+    """Login to LEAP platform."""
+    if is_logged_in():
+        console.print(
+            "[yellow]⚠[/yellow] You are already logged in. "
+            "Run 'leap-bundle logout' first if you want to change your token."
+        )
+        return
+
+    console.print("[blue]ℹ[/blue] Validating API token...")
+    if not validate_api_token(api_token):
+        console.print(
+            "[red]✗[/red] Invalid API token. Please check your token and try again."
+        )
+        raise typer.Exit(1)
+
+    try:
+        set_api_token(api_token)
+        console.print("[green]✓[/green] Successfully logged in to LEAP platform!")
+    except Exception as e:
+        console.print(f"[red]✗[/red] Failed to save login credentials: {e}")
+        raise typer.Exit(1) from None
+
+
+@app.command("logout")
+def logout() -> None:
+    """Logout from LEAP platform."""
+    if not is_logged_in():
+        console.print("[blue]ℹ[/blue] You are not currently logged in.")
+        return
+
+    try:
+        clear_api_token()
+        console.print("[green]✓[/green] Successfully logged out from LEAP platform!")
+    except Exception as e:
+        console.print(f"[red]✗[/red] Failed to clear login credentials: {e}")
+        raise typer.Exit(1) from None
+
+
+@app.command("whoami")
+def whoami() -> None:
+    """Show current user information."""
+    if not is_logged_in():
+        console.print(
+            "[red]✗[/red] You are not logged in. Run 'leap-bundle login' first."
+        )
+        raise typer.Exit(1)
+
+    try:
+        api_token = get_api_token()
+        server_url = get_server_url()
+        api_url = f"{server_url.rstrip('/')}/api/cli/whoami"
+
+        response = requests.get(
+            api_url, headers={"Authorization": f"Bearer {api_token}"}, timeout=10
+        )
+
+        if response.status_code == 200:
+            data = response.json()
+            console.print(f"[green]✓[/green] Logged in as: {data['email']}")
+        else:
+            error_data = (
+                response.json()
+                if response.headers.get("content-type", "").startswith(
+                    "application/json"
+                )
+                else {}
+            )
+            error_message = error_data.get("error", "Failed to get user information")
+            console.print(f"[red]✗[/red] {error_message}")
+            raise typer.Exit(1)
+    except requests.RequestException as e:
+        console.print(f"[red]✗[/red] Failed to connect to server: {e}")
+        raise typer.Exit(1) from None
+    except typer.Exit:
+        raise  # Re-raise typer.Exit without handling it
+    except Exception as e:
+        console.print(f"[red]✗[/red] Unexpected error: {e}")
+        raise typer.Exit(1) from None

leap_bundle/commands/cancel.py

@@ -0,0 +1,35 @@
+"""Cancel command for bundle requests."""
+
+import typer
+from rich.console import Console
+
+from leap_bundle.utils.api_client import APIClient
+from leap_bundle.utils.config import is_logged_in
+
+console = Console()
+
+
+def cancel(
+    request_id: str = typer.Argument(..., help="Bundle request ID to cancel"),
+) -> None:
+    """Cancel a bundle request."""
+
+    if not is_logged_in():
+        console.print(
+            "[red]✗[/red] You must be logged in. Run 'leap-bundle login' first."
+        )
+        raise typer.Exit(1)
+
+    try:
+        client = APIClient()
+        console.print(f"[blue]ℹ[/blue] Cancelling bundle request {request_id}...")
+
+        result = client.cancel_bundle_request(request_id)
+        message = result.get("message", "Request cancelled successfully.")
+
+        console.print(f"[green]✓[/green] {message}")
+
+    except Exception as e:
+        from leap_bundle.utils.api_client import handle_cli_exception
+
+        handle_cli_exception(e)

leap_bundle/commands/config.py

@@ -0,0 +1,31 @@
+"""Configuration commands for LEAP CLI."""
+
+import typer
+from rich.console import Console
+
+from leap_bundle.utils.config import get_config_file_path, load_config, set_server_url
+
+console = Console()
+app = typer.Typer()
+
+
+@app.command("config")
+def config(
+    server: str = typer.Option(None, "--server", help="Set the server URL"),
+) -> None:
+    """Configure LEAP CLI settings."""
+    if server:
+        set_server_url(server)
+        console.print(f"[green]✓[/green] Server URL set to: {server}")
+    else:
+        config_path = get_config_file_path()
+        console.print(f"[blue]ℹ[/blue] Config file location: {config_path}")
+
+        config_data = load_config()
+        if config_data:
+            console.print("\n[blue]Current configuration:[/blue]")
+            for key, value in config_data.items():
+                if key != "api_token":
+                    console.print(f"  {key}: {value}")
+        else:
+            console.print("\n[yellow]No configuration found.[/yellow]")

leap_bundle/commands/create.py

@@ -0,0 +1,87 @@
+"""Create command for bundle requests."""
+
+from pathlib import Path
+
+import typer
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn
+
+from leap_bundle.utils.api_client import APIClient, upload_directory_to_s3
+from leap_bundle.utils.config import is_logged_in
+from leap_bundle.utils.hash import calculate_directory_hash
+
+console = Console()
+
+
+# TODO: allow force recreate in the future
+def create(
+    input_path: str = typer.Argument(..., help="Directory path to upload"),
+    # force_recreate: bool = typer.Option(
+    #     False, "--force", help="Force recreate even if request exists"
+    # ),
+) -> None:
+    """Create a new bundle request and upload directory."""
+
+    if not is_logged_in():
+        console.print(
+            "[red]✗[/red] You must be logged in. Run 'leap-bundle login' first."
+        )
+        raise typer.Exit(1)
+
+    path = Path(input_path)
+    if not path.exists():
+        console.print(f"[red]✗[/red] Directory does not exist: {input_path}")
+        raise typer.Exit(1)
+
+    if not path.is_dir():
+        console.print(f"[red]✗[/red] Path is not a directory: {input_path}")
+        raise typer.Exit(1)
+
+    try:
+        console.print("[blue]ℹ[/blue] Calculating directory hash...")
+        input_hash = calculate_directory_hash(str(path.absolute()))
+
+        client = APIClient()
+        console.print("[blue]ℹ[/blue] Submitting bundle request...")
+
+        result = client.create_bundle_request(str(path.absolute()), input_hash, False)
+
+        if result["exists"]:
+            console.print(f"[yellow]⚠[/yellow] {result['message']}")
+            return
+
+        request_id = result["new_request_id"]
+        signed_url = result["signed_url"]
+
+        console.print(f"[green]✓[/green] Bundle request created with ID: {request_id}")
+
+        console.print("[blue]ℹ[/blue] Starting upload...")
+        client.update_bundle_request_status(request_id, "uploading_started")
+
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            console=console,
+        ) as progress:
+            task = progress.add_task("Uploading directory...", total=None)
+
+            try:
+                upload_directory_to_s3(signed_url, str(path.absolute()))
+                progress.update(task, description="Upload completed!")
+
+                client.update_bundle_request_status(request_id, "uploading_completed")
+                console.print(
+                    f"[green]✓[/green] Upload completed successfully! Request ID: {request_id}"
+                )
+
+            except Exception as upload_error:
+                client.update_bundle_request_status(
+                    request_id, "uploading_failed", str(upload_error)
+                )
+                console.print(f"[red]✗[/red] Upload failed: {upload_error}")
+                raise typer.Exit(1) from upload_error
+
+    except Exception as e:
+        from leap_bundle.utils.api_client import handle_cli_exception
+
+        handle_cli_exception(e)

leap_bundle/commands/download.py

@@ -0,0 +1,78 @@
+"""Download command for bundle requests."""
+
+from pathlib import Path
+from urllib.parse import unquote, urlparse
+
+import typer
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn
+
+from leap_bundle.utils.api_client import APIClient, download_from_s3
+from leap_bundle.utils.config import is_logged_in
+
+console = Console()
+
+
+def download(
+    request_id: str = typer.Argument(..., help="Bundle request ID to download"),
+    output_path: str = typer.Option(
+        ".", "--output-path", help="Directory path to download files to"
+    ),
+) -> None:
+    """Download completed bundle request output."""
+
+    if not is_logged_in():
+        console.print(
+            "[red]✗[/red] You must be logged in. Run 'leap-bundle login' first."
+        )
+        raise typer.Exit(1)
+
+    output_dir = Path(output_path)
+    if not output_dir.exists():
+        console.print(f"[red]✗[/red] Output directory does not exist: {output_path}")
+        raise typer.Exit(1)
+
+    if not output_dir.is_dir():
+        console.print(f"[red]✗[/red] Output path is not a directory: {output_path}")
+        raise typer.Exit(1)
+
+    try:
+        client = APIClient()
+        console.print(
+            f"[blue]ℹ[/blue] Requesting download for bundle request {request_id}..."
+        )
+
+        result = client.download_bundle_request(request_id)
+        signed_url = result["signed_url"]
+        parsed_url = urlparse(signed_url)
+        output_file = Path(unquote(parsed_url.path)).name
+        if not output_file or output_file == "/":
+            output_file = f"bundle-{request_id}.bundle"
+
+        console.print(
+            f"[green]✓[/green] Download URL obtained for request {request_id}"
+        )
+
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            console=console,
+        ) as progress:
+            task = progress.add_task("Downloading bundle output...", total=None)
+
+            try:
+                download_from_s3(signed_url, str(output_file))
+                progress.update(task, description="Download completed!")
+
+                console.print(
+                    f"[green]✓[/green] Download completed successfully! File saved to: {output_file}"
+                )
+
+            except Exception as download_error:
+                console.print(f"[red]✗[/red] Download failed: {download_error}")
+                raise typer.Exit(1) from download_error
+
+    except Exception as e:
+        from leap_bundle.utils.api_client import handle_cli_exception
+
+        handle_cli_exception(e)

leap_bundle/commands/list.py

@@ -0,0 +1,73 @@
+"""List command for bundle requests."""
+
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from leap_bundle.utils.api_client import APIClient
+from leap_bundle.utils.config import is_logged_in
+
+console = Console()
+
+
+def list_requests(
+    request_id: Optional[str] = typer.Argument(
+        None, help="Optional request ID to get details for a specific request"
+    ),
+) -> None:
+    """List bundle requests or get details for a specific request."""
+
+    if not is_logged_in():
+        console.print(
+            "[red]✗[/red] You must be logged in. Run 'leap-bundle login' first."
+        )
+        raise typer.Exit(1)
+
+    try:
+        client = APIClient()
+
+        if request_id:
+            console.print(
+                f"[blue]ℹ[/blue] Fetching details for request {request_id}..."
+            )
+            result = client.get_bundle_request(request_id)
+            request = result["request"]
+
+            console.print("[green]✓[/green] Request Details:")
+            console.print(f"  ID:         {request['external_id']}")
+            console.print(f"  Input Path: {request['input_path']}")
+            console.print(f"  Status:     {request['status']}")
+            console.print(f"  Creation:   {request['created_at']}")
+            console.print(f"  Update:     {request['updated_at']}")
+        else:
+            console.print("[blue]ℹ[/blue] Fetching bundle requests...")
+            result = client.list_bundle_requests()
+            requests = result["requests"]
+
+            if not requests:
+                console.print("[yellow]⚠[/yellow] No bundle requests found.")
+                return
+
+            table = Table(title="Bundle Requests (50 most recent)")
+            table.add_column("ID", style="cyan")
+            table.add_column("Input Path", style="green")
+            table.add_column("Status", style="yellow")
+            table.add_column("Creation", style="blue")
+
+            for request in requests:
+                table.add_row(
+                    str(request["external_id"]),
+                    request["input_path"],
+                    request["status"],
+                    request["created_at"],
+                )
+
+            console.print(table)
+            console.print(f"[green]✓[/green] Found {len(requests)} bundle requests.")
+
+    except Exception as e:
+        from leap_bundle.utils.api_client import handle_cli_exception
+
+        handle_cli_exception(e)

leap_bundle/main.py

@@ -0,0 +1,68 @@
+"""Main entry point for the LEAP CLI."""
+
+import typer
+from rich.console import Console
+
+from leap_bundle.commands.auth import login, logout, whoami
+from leap_bundle.commands.cancel import cancel
+from leap_bundle.commands.config import config
+from leap_bundle.commands.create import create
+from leap_bundle.commands.download import download
+from leap_bundle.commands.list import list_requests
+
+console = Console()
+
+app = typer.Typer(
+    name="leap-bundle",
+    help="Command line interface for the LEAP (Liquid Edge AI Platform) platform.",
+    rich_markup_mode="rich",
+)
+
+
+def version_callback(value: bool) -> None:
+    """Show version information."""
+    if value:
+        from leap_bundle import __version__
+
+        console.print(f"leap-bundle version {__version__}")
+        raise typer.Exit()
+
+
+def help_command(ctx: typer.Context) -> None:
+    """Show help information."""
+    if ctx.parent:
+        console.print(ctx.parent.get_help())
+    else:
+        console.print("Help information not available.")
+
+
+app.command("login")(login)
+app.command("logout")(logout)
+app.command("whoami")(whoami)
+app.command("cancel")(cancel)
+app.command("config")(config)
+app.command("create")(create)
+app.command("download")(download)
+app.command("list")(list_requests)
+app.command("help")(help_command)
+
+
+@app.callback(invoke_without_command=True)
+def main(
+    ctx: typer.Context,
+    version: bool = typer.Option(
+        None,
+        "--version",
+        "-v",
+        callback=version_callback,
+        is_eager=True,
+        help="Show version and exit.",
+    ),
+) -> None:
+    """LEAP CLI - Command line interface for the LEAP platform."""
+    if ctx.invoked_subcommand is None:
+        console.print(ctx.get_help())
+
+
+if __name__ == "__main__":
+    app()

leap_bundle/utils/__init__.py

@@ -0,0 +1 @@
+

leap_bundle/utils/api_client.py

@@ -0,0 +1,211 @@
+"""API client utilities for LEAP CLI."""
+
+from typing import Any, Dict, Literal, Optional, cast
+
+import requests
+
+from leap_bundle.utils.config import get_api_token, get_server_url
+
+
+class APIClient:
+    """Client for LEAP API interactions."""
+
+    def __init__(self) -> None:
+        self.server_url = get_server_url()
+        self.api_token = get_api_token()
+
+    def _get_headers(self) -> Dict[str, str]:
+        """Get headers with authentication."""
+        if not self.api_token:
+            raise ValueError(
+                "No API token found. Please run 'leap-bundle login' first."
+            )
+
+        return {
+            "Authorization": f"Bearer {self.api_token}",
+            "Content-Type": "application/json",
+        }
+
+    def create_bundle_request(
+        self, input_path: str, input_hash: str, force_recreate: bool = False
+    ) -> Dict[str, Any]:
+        """Create a new bundle request."""
+        url = f"{self.server_url.rstrip('/')}/api/cli/bundle-requests"
+        payload = {
+            "input_path": input_path,
+            "input_hash": input_hash,
+            "force_recreate": force_recreate,
+        }
+
+        response = requests.post(
+            url, json=payload, headers=self._get_headers(), timeout=30
+        )
+
+        if response.status_code == 409:
+            return {"exists": True, "message": response.json().get("message", "")}
+        elif response.status_code == 200:
+            return {"exists": False, **response.json()}
+        else:
+            try:
+                error_data = response.json()
+                error_msg = error_data.get(
+                    "error", f"HTTP {response.status_code} error"
+                )
+            except ValueError:
+                error_msg = f"HTTP {response.status_code} error"
+            raise requests.HTTPError(error_msg, response=response)
+
+    def update_bundle_request_status(
+        self,
+        request_id: str,
+        status: Literal["uploading_started", "uploading_completed", "uploading_failed"],
+        user_message: Optional[str] = None,
+    ) -> None:
+        """Update bundle request status via PATCH endpoint."""
+        url = f"{self.server_url.rstrip('/')}/api/cli/bundle-requests/{request_id}"
+        payload: Dict[str, Any] = {"status": status}
+        if user_message:
+            payload["user_message"] = user_message
+
+        response = requests.patch(
+            url, json=payload, headers=self._get_headers(), timeout=30
+        )
+        response.raise_for_status()
+
+    def list_bundle_requests(self) -> Dict[str, Any]:
+        """List bundle requests for the authenticated user."""
+        url = f"{self.server_url.rstrip('/')}/api/cli/bundle-requests"
+
+        response = requests.get(url, headers=self._get_headers(), timeout=30)
+
+        if response.status_code != 200:
+            try:
+                error_data = response.json()
+                error_msg = error_data.get(
+                    "error", f"HTTP {response.status_code} error"
+                )
+            except ValueError:
+                error_msg = f"HTTP {response.status_code} error"
+            raise requests.HTTPError(error_msg, response=response)
+
+        return cast(Dict[str, Any], response.json())
+
+    def get_bundle_request(self, request_id: str) -> Dict[str, Any]:
+        """Get details for a specific bundle request."""
+        url = f"{self.server_url.rstrip('/')}/api/cli/bundle-requests/{request_id}"
+
+        response = requests.get(url, headers=self._get_headers(), timeout=30)
+
+        if response.status_code != 200:
+            try:
+                error_data = response.json()
+                error_msg = error_data.get(
+                    "error", f"HTTP {response.status_code} error"
+                )
+            except ValueError:
+                error_msg = f"HTTP {response.status_code} error"
+            raise requests.HTTPError(error_msg, response=response)
+
+        return cast(Dict[str, Any], response.json())
+
+    def download_bundle_request(self, request_id: str) -> Dict[str, Any]:
+        """Get download URL for a completed bundle request."""
+        url = f"{self.server_url.rstrip('/')}/api/cli/bundle-requests/{request_id}/download"
+
+        response = requests.post(url, headers=self._get_headers(), timeout=30)
+
+        if response.status_code != 200:
+            try:
+                error_data = response.json()
+                error_msg = error_data.get(
+                    "error", f"HTTP {response.status_code} error"
+                )
+            except ValueError:
+                error_msg = f"HTTP {response.status_code} error"
+            raise requests.HTTPError(error_msg, response=response)
+
+        return cast(Dict[str, Any], response.json())
+
+    def cancel_bundle_request(self, request_id: str) -> Dict[str, Any]:
+        """Cancel a bundle request."""
+        url = f"{self.server_url.rstrip('/')}/api/cli/bundle-requests/{request_id}"
+
+        response = requests.delete(url, headers=self._get_headers(), timeout=30)
+
+        if response.status_code not in [200, 404]:
+            try:
+                error_data = response.json()
+                error_msg = error_data.get(
+                    "error", f"HTTP {response.status_code} error"
+                )
+            except ValueError:
+                error_msg = f"HTTP {response.status_code} error"
+            raise requests.HTTPError(error_msg, response=response)
+
+        result: Dict[str, Any] = response.json()
+        return result
+
+
+def upload_directory_to_s3(
+    signed_url_data: Dict[str, Any], directory_path: str
+) -> None:
+    """Upload directory to S3 using signed URL."""
+    import os
+    from pathlib import Path
+
+    path = Path(directory_path)
+    url = signed_url_data["url"]
+    fields = signed_url_data["fields"]
+
+    for root, _, filenames in os.walk(path):
+        for filename in filenames:
+            file_path = Path(root) / filename
+            relative_path = file_path.relative_to(path)
+
+            form_data = fields.copy()
+            form_data["key"] = form_data["key"].replace(
+                "${filename}", str(relative_path)
+            )
+
+            with open(file_path, "rb") as f:
+                files = {"file": f}
+                response = requests.post(url, data=form_data, files=files, timeout=300)
+                response.raise_for_status()
+
+
+def extract_error_message(response: requests.Response) -> str:
+    """Extract error message from HTTP response, preferring server-provided error field."""
+    try:
+        error_data = response.json()
+        return str(error_data.get("error", f"HTTP {response.status_code} error"))
+    except ValueError:
+        return f"HTTP {response.status_code} error"
+
+
+def handle_cli_exception(e: Exception) -> None:
+    """Handle CLI exceptions with proper error message extraction and display."""
+    import typer
+    from rich.console import Console
+
+    console = Console()
+
+    if hasattr(e, "response") and e.response is not None:
+        error_message = extract_error_message(e.response)
+        console.print(f"[red]✗[/red] {error_message}")
+    else:
+        console.print(f"[red]✗[/red] Error: {e}")
+    raise typer.Exit(1) from e
+
+
+def download_from_s3(signed_url: str, output_path: str) -> None:
+    """Download file from S3 using signed URL."""
+    from pathlib import Path
+
+    output_file = Path(output_path)
+    output_file.parent.mkdir(parents=True, exist_ok=True)
+
+    response = requests.get(signed_url, timeout=300)
+    response.raise_for_status()
+
+    with open(output_file, "wb") as f:
+        f.write(response.content)

leap_bundle/utils/config.py

@@ -0,0 +1,98 @@
+"""Configuration utilities for LEAP CLI."""
+
+import os
+from pathlib import Path
+from typing import Optional
+
+import yaml
+
+
+def get_config_file_path() -> Path:
+    """Get the path to the LEAP CLI config file."""
+    return Path.home() / ".liquid-leap"
+
+
+def load_config() -> dict[str, str]:
+    """Load configuration from the config file."""
+    config_path = get_config_file_path()
+    if not config_path.exists():
+        return {}
+
+    try:
+        with open(config_path) as f:
+            return yaml.safe_load(f) or {}
+    except (yaml.YAMLError, OSError):
+        return {}
+
+
+def save_config(config: dict[str, str]) -> None:
+    """Save configuration to the config file."""
+    config_path = get_config_file_path()
+
+    config_with_version = {"version": 1, **config}
+
+    try:
+        with open(config_path, "w") as f:
+            yaml.safe_dump(config_with_version, f, default_flow_style=False)
+
+        os.chmod(config_path, 0o600)
+    except OSError:
+        pass
+
+
+def is_logged_in() -> bool:
+    """Check if the user is currently logged in."""
+    config = load_config()
+    return bool(config.get("api_token"))
+
+
+def get_api_token() -> Optional[str]:
+    """Get the stored API token."""
+    config = load_config()
+    return config.get("api_token")
+
+
+def get_server_url() -> str:
+    """Get the configured server URL."""
+    config = load_config()
+    return config.get("server_url", "https://leap.liquid.ai")
+
+
+def set_server_url(url: str) -> None:
+    """Store the server URL in the config file."""
+    config_path = get_config_file_path()
+    config_exists = config_path.exists()
+
+    config = load_config()
+    config["server_url"] = url
+    save_config(config)
+
+    if not config_exists:
+        from rich.console import Console
+
+        console = Console()
+        console.print(f"[blue]ℹ[/blue] Config file created at: {config_path}")
+
+
+def set_api_token(token: str) -> None:
+    """Store the API token in the config file."""
+    config_path = get_config_file_path()
+    config_exists = config_path.exists()
+
+    config = load_config()
+    config["api_token"] = token
+    save_config(config)
+
+    if not config_exists:
+        from rich.console import Console
+
+        console = Console()
+        console.print(f"[blue]ℹ[/blue] Config file created at: {config_path}")
+
+
+def clear_api_token() -> None:
+    """Remove the API token from the config file."""
+    config = load_config()
+    if "api_token" in config:
+        del config["api_token"]
+        save_config(config)

leap_bundle/utils/hash.py

@@ -0,0 +1,31 @@
+"""Hashing utilities for LEAP CLI."""
+
+import hashlib
+import os
+from pathlib import Path
+from typing import List
+
+
+def calculate_directory_hash(directory_path: str) -> str:
+    """Calculate SHA256 hash of all files in a directory."""
+    path = Path(directory_path)
+    if not path.exists() or not path.is_dir():
+        raise ValueError(f"Directory does not exist: {directory_path}")
+
+    files: List[Path] = []
+    for root, _, filenames in os.walk(path):
+        for filename in filenames:
+            files.append(Path(root) / filename)
+
+    files.sort()
+
+    hasher = hashlib.sha256()
+    for file_path in files:
+        relative_path = file_path.relative_to(path)
+        hasher.update(str(relative_path).encode("utf-8"))
+
+        with open(file_path, "rb") as f:
+            for chunk in iter(lambda: f.read(4096), b""):
+                hasher.update(chunk)
+
+    return hasher.hexdigest()

leap_bundle-0.0.1a1.dist-info/METADATA

@@ -0,0 +1,89 @@
+Metadata-Version: 2.4
+Name: leap-bundle
+Version: 0.0.1a1
+Summary: Command line interface for Liquid Edge AI Platform (LEAP)
+Project-URL: Homepage, https://leap.liquid.ai
+Author-email: Liquid AI <leap@liquid.ai>
+License: LFM Open License v1.0
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: Other/Proprietary License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8
+Requires-Dist: pyyaml>=6.0.0
+Requires-Dist: requests>=2.31.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: typer>=0.9.0
+Provides-Extra: dev
+Requires-Dist: mypy>=1.0.0; extra == 'dev'
+Requires-Dist: pytest-cov>=4.0.0; extra == 'dev'
+Requires-Dist: pytest>=7.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.1.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# leap-bundle
+
+Command line interface for Liquid Edge AI Platform (LEAP).
+
+## Installation
+
+```bash
+pip install leap-bundle
+```
+
+## Commands
+
+| Command | Description |
+| --- | --- |
+| `leap-bundle login <api-token>` | Authenticate with LEAP using API token |
+| `leap-bundle whoami` | Show current authenticated user |
+| `leap-bundle logout` | Logout from LEAP |
+| `leap-bundle config` | Show current configuration |
+| `leap-bundle config --server <url>` | Set server URL (default: https://leap.liquid.ai) |
+| `leap-bundle create` | Submit new bundle request |
+| `leap-bundle list` | List all bundle requests |
+| `leap-bundle list <request-id>` | Show details of a specific request |
+| `leap-bundle cancel <request-id>` | Cancel a bundle request |
+| `leap-bundle download <request-id>` | Download the bundle file for a specific request |
+
+## Development
+
+This package uses `uv` for dependency management.
+
+### Setup
+
+```bash
+# Install uv if you haven't already
+curl -LsSf https://astral.sh/uv/install.sh | sh
+
+# Install dependencies
+uv sync --dev
+```
+
+### Development Commands
+
+| `uv` command | `npm` command | Description |
+| --- | --- | --- |
+| `uv run ruff check .` | `npm run lint` | Run code linting |
+| `uv run ruff format .` | `npm run format` | Format code using ruff |
+| `uv run mypy .` | `npm run typecheck` | Run type checking with mypy |
+| `uv run pytest` | `npm run test` | Run tests using pytest |
+| | `npm run check` | Run all above checks |
+
+### Local Development
+
+```bash
+# Install the package in virtual environment
+uv pip install -e .
+
+# Run the CLI
+uv run leap-bundle --help
+# Or activate the virtual environment and run directly
+source .venv/bin/activate
+leap-bundle --help
+```

leap_bundle-0.0.1a1.dist-info/RECORD

@@ -0,0 +1,17 @@
+leap_bundle/__init__.py,sha256=sXLh7g3KC4QCFxcZGBTpG2scR7hmmBsMjq6LqRptkRg,22
+leap_bundle/main.py,sha256=GZmsSoFxRWoiNjWahiFJ-DAUqQjlvMlUuRTfyy3jsW4,1755
+leap_bundle/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+leap_bundle/commands/auth.py,sha256=ZILBhXoAsVRFdjLc7uvo9zIoKTnAjhNoA8KWXE3ERoA,3589
+leap_bundle/commands/cancel.py,sha256=qZcQGxot6Oqto9etBuoegAafHfYt8kunEEyHfiM_bOg,968
+leap_bundle/commands/config.py,sha256=n9mFW2c9FrZRUJ7fC_kGZ0JE1pOGLJbURi3lAsZVLe4,995
+leap_bundle/commands/create.py,sha256=TI2Xmx8fsklqKUOkUipkH-h_7ETAqnfza-Wwp6kdAhg,3057
+leap_bundle/commands/download.py,sha256=513Qx2iRzrGjcFEA225zqV99rNYbUUvCl386i6QF5zo,2608
+leap_bundle/commands/list.py,sha256=R4fe9f_g5baoyU3rd8C1FgY2wbnL_qATXVTk-2nj3Rs,2477
+leap_bundle/utils/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+leap_bundle/utils/api_client.py,sha256=vdE0vEN0K8RThpsAqGX1bL-PdTB1z3DO-9BCeucuOmU,7560
+leap_bundle/utils/config.py,sha256=YuvlUDaSX-Tl3TWi7JtOb5m3fsys6K4tjrny2WrXu6k,2493
+leap_bundle/utils/hash.py,sha256=Bv-WV34-PuZXSvtfMf6Cqc-_9_I68dBmlNcsjwXsGbI,896
+leap_bundle-0.0.1a1.dist-info/METADATA,sha256=rsCZNAKYkewh1ppriLzFuJcii-FwVA4l2qaHBzFSriQ,2759
+leap_bundle-0.0.1a1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+leap_bundle-0.0.1a1.dist-info/entry_points.txt,sha256=n0Yyt_fEhDZJsY7R2i9EGuhFEud11Qlm_lZZmDXo0k0,53
+leap_bundle-0.0.1a1.dist-info/RECORD,,

leap_bundle-0.0.1a1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

leap_bundle-0.0.1a1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+leap-bundle = leap_bundle.main:app