pythonanywhere-clis 1.0.0__py3-none-any.whl

pa_cli/cli/consoles_cmd.py

@@ -0,0 +1,151 @@
+import time
+import uuid
+
+import typer
+
+from pa_cli.api.consoles import ConsolesClient
+from pa_cli.cli.utils import get_client
+from pa_cli.config import Config
+from pa_cli.exceptions import AuthError, NetworkError, NotFoundError
+
+app = typer.Typer(help="Manage consoles on PythonAnywhere.")
+
+
+@app.command("list")
+def list_consoles():
+    """List all consoles."""
+    account, client = get_client(ConsolesClient)
+    consoles = client.list(account["username"])
+    if not consoles:
+        typer.echo("No consoles found.")
+        return
+    for console in consoles:
+        typer.echo(f"ID: {console['id']}, Name: {console['name']}")
+
+
+@app.command()
+def activate(
+    console_id: int = typer.Argument(..., help="Console ID"),
+):
+    """Activate a console via WebSocket (requires login)."""
+    try:
+        from pa_cli.crawler.console_crawler import ConsoleCrawler
+
+        account = Config.load(verbose=True)
+
+        if "password" not in account:
+            typer.echo("Password not found. Run 'pa account login' first.", err=True)
+            raise typer.Exit(code=1)
+
+        crawler = ConsoleCrawler(host=account.get("host", "www.pythonanywhere.com"))
+        crawler.login(account["username"], account["password"])
+        crawler.activate(account["username"], console_id)
+        typer.echo(f"Console {console_id} activated successfully.")
+    except AuthError as e:
+        typer.echo(f"Auth error: {e}", err=True)
+        raise typer.Exit(code=1)
+    except NetworkError as e:
+        typer.echo(f"Network error: {e}", err=True)
+        raise typer.Exit(code=1)
+
+
+@app.command()
+def create(
+    executable: str = typer.Option("bash", help="Console executable"),
+):
+    """Create a new console."""
+    account, client = get_client(ConsolesClient)
+    result = client.create(account["username"], executable)
+    typer.echo(f"Console created: id={result['id']}, executable={result['executable']}")
+
+
+@app.command()
+def send(
+    console_id: int = typer.Argument(..., help="Console ID"),
+    command: str = typer.Argument(..., help="Command to send"),
+    wait: bool = typer.Option(True, "--wait/--no-wait", "-w/-W", help="Wait for output"),
+    timeout: int = typer.Option(30, "--timeout", "-t", help="Max seconds to wait for output"),
+):
+    """Send input to a console and get output."""
+    account, client = get_client(ConsolesClient)
+
+    if not wait:
+        client.send_input(account["username"], console_id, command + "\n")
+        typer.echo(f"Sent to console {console_id}: {command}")
+        return
+
+    # Get baseline output before sending command
+    baseline = client.get_output(account["username"], console_id)
+    baseline_output = baseline.get("output", "")
+
+    # Generate unique completion marker (timestamp + random hex)
+    import time as _time
+    marker = f"__PA_CLI_DONE_{int(_time.time())}_{uuid.uuid4().hex}__"
+
+    # Send command + marker echo
+    client.send_input(
+        account["username"],
+        console_id,
+        f"{command}\necho {marker}\n",
+    )
+
+    # Poll for marker
+    elapsed = 0.0
+    poll_interval = 0.5
+    while elapsed < timeout:
+        time.sleep(poll_interval)
+        elapsed += poll_interval
+        result = client.get_output(account["username"], console_id)
+        output = result.get("output", "")
+
+        if marker in output and output != baseline_output:
+            # Extract new content (after baseline)
+            new_output = output[len(baseline_output):]
+            # Find and remove marker line
+            lines = new_output.split("\n")
+            user_lines = []
+            for line in lines:
+                if marker in line:
+                    break
+                user_lines.append(line)
+            typer.echo("\n".join(user_lines).strip() or "(no output)")
+            return
+
+    typer.echo("Timeout waiting for command output", err=True)
+    raise typer.Exit(code=1)
+
+
+@app.command("get-or-create")
+def get_or_create(
+    executable: str = typer.Option("bash", "--executable", "-e", help="Console executable"),
+):
+    """Get an existing console or create a new one (auto-manage lifecycle)."""
+    try:
+        from pa_cli.crawler.console_crawler import ConsoleCrawler
+
+        account = Config.load(verbose=True)
+
+        if "password" not in account:
+            typer.echo("Password not found. Run 'pa account login' first.", err=True)
+            raise typer.Exit(code=1)
+
+        crawler = ConsoleCrawler(host=account.get("host", "www.pythonanywhere.com"))
+        crawler.login(account["username"], account["password"])
+        console_id = crawler.get_or_create(account["username"], executable=executable)
+        typer.echo(f"Console ready: {console_id}")
+    except AuthError as e:
+        typer.echo(f"Auth error: {e}", err=True)
+        raise typer.Exit(code=1)
+    except NetworkError as e:
+        typer.echo(f"Network error: {e}", err=True)
+        raise typer.Exit(code=1)
+
+
+@app.command()
+def kill(
+    console_id: int = typer.Argument(..., help="Console ID"),
+):
+    """Kill a console."""
+    account, client = get_client(ConsolesClient)
+    client.kill(account["username"], console_id)
+    typer.echo(f"Console {console_id} killed.")

pa_cli/cli/deploy_cmd.py

@@ -0,0 +1,44 @@
+import typer
+
+from pa_cli.config import Config
+from pa_cli.exceptions import PACliError, APIError, NetworkError
+from pa_cli.workflows.deploy import deploy as deploy_workflow
+
+app = typer.Typer(help="Deploy a local project to PythonAnywhere.")
+
+
+@app.command()
+def deploy(
+    local_dir: str = typer.Argument(..., help="Local project directory"),
+    domain: str = typer.Option(None, "--domain", "-d", help="Domain name (default: {username}.pythonanywhere.com)"),
+    python_version: str = typer.Option("python310", "--python", "-p", help="Python version"),
+    dry_run: bool = typer.Option(False, "--dry-run", "-n", help="Preview deploy without executing"),
+):
+    """Deploy a local project to PythonAnywhere."""
+    try:
+        account = Config.load(verbose=True)
+
+        if domain is None:
+            domain = f"{account['username']}.pythonanywhere.com"
+
+        url = deploy_workflow(
+            local_dir=local_dir,
+            username=account["username"],
+            token=account["token"],
+            host=account["host"],
+            domain=domain,
+            python_version=python_version,
+            dry_run=dry_run,
+        )
+
+        if not dry_run:
+            typer.echo(f"\nDeployed! Visit: {url}")
+    except NetworkError as e:
+        typer.echo(f"Network error: {e}", err=True)
+        raise typer.Exit(code=1)
+    except APIError as e:
+        typer.echo(f"API error: {e}", err=True)
+        raise typer.Exit(code=1)
+    except PACliError as e:
+        typer.echo(f"Deploy failed: {e}", err=True)
+        raise typer.Exit(code=1)

pa_cli/cli/files_cmd.py

@@ -0,0 +1,285 @@
+from pathlib import Path
+
+import typer
+
+from pa_cli.api.files import FilesClient
+from pa_cli.cli.utils import get_client, fix_remote_path
+from pa_cli.exceptions import APIError, NetworkError, NotFoundError
+
+app = typer.Typer(help="Manage files on PythonAnywhere.")
+
+
+@app.callback()
+def main():
+    """Manage files on PythonAnywhere."""
+    pass
+
+
+def _resolve_path(path: str | None, username: str) -> str:
+    """Resolve remote path. Relative paths are under /home/{username}/."""
+    if not path:
+        return f"/home/{username}/"
+    path = fix_remote_path(path)
+    if path.startswith("/"):
+        return path if path.endswith("/") else path + "/"
+    return f"/home/{username}/{path}".rstrip("/") + "/"
+
+
+@app.command("ls")
+def ls(
+    path: str = typer.Argument(None, help="Remote path to list (default: home directory)"),
+):
+    """List files and directories on PythonAnywhere."""
+    try:
+        account, client = get_client(FilesClient)
+
+        remote_path = _resolve_path(path, account["username"])
+        items = client.list(account["username"], remote_path)
+
+        if not items:
+            typer.echo("(empty directory)")
+            return
+
+        for name in sorted(items.keys()):
+            item_type = items[name].get("type", "file")
+            if item_type == "directory":
+                typer.echo(f"  {name}/")
+            else:
+                typer.echo(f"  {name}")
+    except NotFoundError as e:
+        typer.echo(f"Path not found: {e}", err=True)
+        raise typer.Exit(code=1)
+    except NetworkError as e:
+        typer.echo(f"Network error: {e}", err=True)
+        raise typer.Exit(code=1)
+    except APIError as e:
+        typer.echo(f"API error: {e}", err=True)
+        raise typer.Exit(code=1)
+
+
+@app.command()
+def download(
+    remote_path: str = typer.Argument(..., help="Remote path to download"),
+    local_path: str = typer.Argument(None, help="Local destination (default: current directory)"),
+    recursive: bool = typer.Option(False, "-r", "--recursive", help="Download directory recursively"),
+):
+    """Download a file or directory from PythonAnywhere."""
+    try:
+        account, client = get_client(FilesClient)
+
+        resolved = _resolve_path(remote_path, account["username"])
+
+        # Check if remote is a directory by listing its parent
+        parent = resolved.rsplit("/", 2)[0] + "/"
+        name = resolved.rstrip("/").rsplit("/", 1)[-1]
+        parent_items = client.list(account["username"], parent)
+
+        is_directory = False
+        if name in parent_items:
+            is_directory = parent_items[name].get("type") == "directory"
+
+        if is_directory and not recursive:
+            typer.echo("Error: Use -r/--recursive to download directories")
+            raise typer.Exit(code=1)
+
+        if is_directory:
+            target_dir = Path(local_path) if local_path else Path(name)
+            target_dir.mkdir(parents=True, exist_ok=True)
+            count = _download_recursive(client, account["username"], resolved, target_dir)
+            typer.echo(f"Downloaded {count} files to {target_dir}")
+        else:
+            file_path = resolved.rstrip("/")
+            content = client.download(account["username"], file_path)
+            target = Path(local_path) if local_path else Path(file_path.split("/")[-1])
+            target.parent.mkdir(parents=True, exist_ok=True)
+            target.write_bytes(content)
+            typer.echo(f"Downloaded {remote_path} -> {target}")
+    except NotFoundError as e:
+        typer.echo(f"File not found: {e}", err=True)
+        raise typer.Exit(code=1)
+    except NetworkError as e:
+        typer.echo(f"Network error: {e}", err=True)
+        raise typer.Exit(code=1)
+    except APIError as e:
+        typer.echo(f"API error: {e}", err=True)
+        raise typer.Exit(code=1)
+
+
+def _download_recursive(client, username, remote_dir, local_dir):
+    """Recursively download a directory. Returns file count."""
+    items = client.list(username, remote_dir)
+    count = 0
+    for name, info in items.items():
+        remote = f"{remote_dir.rstrip('/')}/{name}"
+        local = local_dir / name
+        if info.get("type") == "directory":
+            local.mkdir(parents=True, exist_ok=True)
+            count += _download_recursive(client, username, remote + "/", local)
+        else:
+            content = client.download(username, remote)
+            local.parent.mkdir(parents=True, exist_ok=True)
+            local.write_bytes(content)
+            count += 1
+    return count
+
+
+@app.command()
+def upload(
+    local_path: str = typer.Argument(..., help="Local file or directory path"),
+    remote_path: str = typer.Argument(..., help="Remote path on PythonAnywhere"),
+    recursive: bool = typer.Option(False, "-r", "--recursive", help="Upload directory recursively"),
+):
+    """Upload a file or directory to PythonAnywhere."""
+    local = Path(local_path)
+
+    if not local.exists():
+        typer.echo(f"Error: {local_path} does not exist")
+        raise typer.Exit(code=1)
+
+    if local.is_dir() and not recursive:
+        typer.echo("Error: Use -r/--recursive to upload directories")
+        raise typer.Exit(code=1)
+
+    try:
+        account, client = get_client(FilesClient)
+
+        if local.is_file():
+            content = local.read_bytes()
+            status = client.upload(account["username"], remote_path, content)
+            typer.echo(f"Uploaded {local_path} -> {remote_path} (HTTP {status})")
+        else:
+            # Recursive directory upload
+            count = 0
+            for file in local.rglob("*"):
+                if file.is_file():
+                    relative = file.relative_to(local)
+                    remote = f"{remote_path.rstrip('/')}/{relative}".replace("\\", "/")
+                    content = file.read_bytes()
+                    client.upload(account["username"], remote, content)
+                    count += 1
+            typer.echo(f"Uploaded {count} files to {remote_path}")
+    except NotFoundError as e:
+        typer.echo(f"Path not found: {e}", err=True)
+        raise typer.Exit(code=1)
+    except NetworkError as e:
+        typer.echo(f"Network error: {e}", err=True)
+        raise typer.Exit(code=1)
+    except APIError as e:
+        typer.echo(f"API error: {e}", err=True)
+        raise typer.Exit(code=1)
+
+
+@app.command()
+def rm(
+    path: str = typer.Argument(..., help="Remote path to delete"),
+    recursive: bool = typer.Option(False, "-r", "--recursive", help="Delete directory recursively"),
+    force: bool = typer.Option(False, "-f", "--force", help="Skip confirmation"),
+):
+    """Delete a file or directory on PythonAnywhere."""
+    try:
+        account, client = get_client(FilesClient)
+
+        resolved = _resolve_path(path, account["username"])
+
+        # Check if target is a directory
+        parent = resolved.rsplit("/", 2)[0] + "/"
+        name = resolved.rstrip("/").rsplit("/", 1)[-1]
+        parent_items = client.list(account["username"], parent)
+
+        is_directory = False
+        if name in parent_items:
+            is_directory = parent_items[name].get("type") == "directory"
+
+        if is_directory and not recursive:
+            typer.echo("Error: Use -r/--recursive to delete directories")
+            raise typer.Exit(code=1)
+
+        if not force:
+            if is_directory:
+                confirm = typer.confirm(f"Are you sure you want to delete '{path}' and all its contents?")
+            else:
+                confirm = typer.confirm(f"Are you sure you want to delete '{path}'?")
+            if not confirm:
+                typer.echo("Cancelled.")
+                raise typer.Exit()
+
+        file_path = resolved.rstrip("/")
+        client.delete(account["username"], file_path)
+
+        if is_directory:
+            typer.echo(f"Deleted {path} (recursive)")
+        else:
+            typer.echo(f"Deleted {path}")
+    except NotFoundError as e:
+        typer.echo(f"File not found: {e}", err=True)
+        raise typer.Exit(code=1)
+    except NetworkError as e:
+        typer.echo(f"Network error: {e}", err=True)
+        raise typer.Exit(code=1)
+    except APIError as e:
+        typer.echo(f"API error: {e}", err=True)
+        raise typer.Exit(code=1)
+
+
+@app.command()
+def share(
+    remote_path: str = typer.Argument(..., help="Remote path to share"),
+):
+    """Share a file and get a share link."""
+    try:
+        account, client = get_client(FilesClient)
+        resolved = _resolve_path(remote_path, account["username"])
+        share_url = client.share(account["username"], resolved)
+        full_url = f"https://www.pythonanywhere.com{share_url}"
+        typer.echo(f"Share link: {full_url}")
+    except NotFoundError as e:
+        typer.echo(f"File not found: {e}", err=True)
+        raise typer.Exit(code=1)
+    except NetworkError as e:
+        typer.echo(f"Network error: {e}", err=True)
+        raise typer.Exit(code=1)
+    except APIError as e:
+        typer.echo(f"API error: {e}", err=True)
+        raise typer.Exit(code=1)
+
+
+@app.command()
+def unshare(
+    remote_path: str = typer.Argument(..., help="Remote path to unshare"),
+):
+    """Stop sharing a file."""
+    try:
+        account, client = get_client(FilesClient)
+        resolved = _resolve_path(remote_path, account["username"])
+        client.unshare(account["username"], resolved)
+        typer.echo(f"Stopped sharing: {remote_path}")
+    except NotFoundError as e:
+        typer.echo(f"File not found或未分享: {e}", err=True)
+        raise typer.Exit(code=1)
+    except NetworkError as e:
+        typer.echo(f"Network error: {e}", err=True)
+        raise typer.Exit(code=1)
+    except APIError as e:
+        typer.echo(f"API error: {e}", err=True)
+        raise typer.Exit(code=1)
+
+
+@app.command("share-status")
+def share_status(
+    remote_path: str = typer.Argument(..., help="Remote path to check"),
+):
+    """Check if a file is shared."""
+    try:
+        account, client = get_client(FilesClient)
+        resolved = _resolve_path(remote_path, account["username"])
+        share_url = client.get_share_status(account["username"], resolved)
+        full_url = f"https://www.pythonanywhere.com{share_url}"
+        typer.echo(f"File is shared: {full_url}")
+    except NotFoundError:
+        typer.echo(f"File is not shared: {remote_path}")
+    except NetworkError as e:
+        typer.echo(f"Network error: {e}", err=True)
+        raise typer.Exit(code=1)
+    except APIError as e:
+        typer.echo(f"API error: {e}", err=True)
+        raise typer.Exit(code=1)

pa_cli/cli/init_cmd.py

@@ -0,0 +1,61 @@
+import typer
+
+from pa_cli.config import Config
+from pa_cli.crawler.account_crawler import AccountCrawler
+from pa_cli.exceptions import AuthError, NetworkError, NotFoundError
+
+app = typer.Typer(help="Configure PythonAnywhere account.")
+
+
+@app.callback(invoke_without_command=True)
+def init_callback(
+    ctx: typer.Context,
+    username: str = typer.Option(None, "--username", "-u", help="PythonAnywhere username"),
+    password: str = typer.Option(None, "--password", "-p", help="Account password"),
+    host: str = typer.Option("www.pythonanywhere.com", "--host", "-h", help="PythonAnywhere host"),
+):
+    """Interactive setup for PythonAnywhere account.
+
+    Examples:
+        pa init                                    # Interactive mode
+        pa init -u myuser -p mypass                # Command-line mode
+        pa init -u myuser -p mypass -h eu.pythonanywhere.com
+    """
+    if ctx.invoked_subcommand is not None:
+        return
+
+    # Use command-line args if provided, otherwise prompt interactively
+    if username is None:
+        username = typer.prompt("PythonAnywhere username")
+    if password is None:
+        password = typer.prompt("Password", hide_input=True)
+
+    # Save credentials to config first so AccountCrawler can read them
+    Config.save(username=username, password=password, host=host)
+
+    # Auto-login and fetch API token
+    try:
+        crawler = AccountCrawler()
+        crawler.login()
+
+        # Try to get existing token, create one if it doesn't exist
+        try:
+            token = crawler.get_token()
+            Config.save(token=token)
+            typer.echo(f"Account '{username}' configured successfully.")
+            typer.echo(f"API token: {token}")
+        except NotFoundError:
+            token = crawler.create_token()
+            Config.save(token=token)
+            typer.echo(f"Account '{username}' configured successfully.")
+            typer.echo(f"Token created: {token}")
+    except AuthError as e:
+        typer.echo(f"Auth error: {e}", err=True)
+        typer.echo("Don't have an account? Register with: pa register", err=True)
+        raise typer.Exit(code=1)
+    except NetworkError as e:
+        typer.echo(f"Network error: {e}", err=True)
+        raise typer.Exit(code=1)
+    except NotFoundError as e:
+        typer.echo(f"Not found: {e}", err=True)
+        raise typer.Exit(code=1)

pa_cli/cli/main.py

@@ -0,0 +1,69 @@
+import logging
+import sys
+
+import typer
+
+from pa_cli.cli.init_cmd import app as init_app
+from pa_cli.cli.files_cmd import app as files_app
+from pa_cli.cli.consoles_cmd import app as consoles_app
+from pa_cli.cli.webapps_cmd import app as webapps_app
+from pa_cli.cli.deploy_cmd import app as deploy_app
+from pa_cli.cli.account_cmd import app as account_app
+from pa_cli.cli.register_cmd import app as register_app
+from pa_cli.cli.status_cmd import app as status_app
+from pa_cli.cli.tasks_cmd import app as tasks_app
+from pa_cli.cli.always_on_cmd import app as always_on_app
+
+try:
+    from importlib.metadata import version
+    __version__ = version("pa-cli")
+except Exception:
+    __version__ = "0.0.0"
+
+
+def version_callback(value: bool):
+    if value:
+        typer.echo(f"pa-cli {__version__}")
+        raise typer.Exit()
+
+
+def verbose_callback(value: bool):
+    if value:
+        logging.basicConfig(
+            level=logging.DEBUG,
+            format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+            stream=sys.stderr,
+        )
+    return value
+
+
+app = typer.Typer(
+    help="CLI tool for automating PythonAnywhere deployments.",
+    no_args_is_help=True,
+)
+
+
+@app.callback()
+def main(
+    version: bool = typer.Option(False, "--version", "-V", help="Show version and exit", callback=version_callback, is_eager=True),
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="Enable verbose logging", callback=verbose_callback, is_eager=True),
+):
+    pass
+
+# Direct commands (single command)
+app.add_typer(init_app, name="init", help="Configure PythonAnywhere account")
+app.add_typer(deploy_app, name="deploy", help="Deploy a local project to PythonAnywhere")
+app.add_typer(register_app, name="register", help="Register a new PythonAnywhere account")
+
+# Command groups (multiple subcommands)
+app.add_typer(files_app, name="files", help="Manage files on PythonAnywhere")
+app.add_typer(consoles_app, name="console", help="Manage consoles on PythonAnywhere")
+app.add_typer(webapps_app, name="webapp", help="Manage web apps on PythonAnywhere")
+app.add_typer(account_app, name="account", help="Account management")
+app.add_typer(status_app, name="status", help="Query system status and resource usage")
+app.add_typer(tasks_app, name="tasks", help="Manage scheduled tasks on PythonAnywhere")
+app.add_typer(always_on_app, name="always-on", help="Manage always-on tasks on PythonAnywhere")
+
+
+if __name__ == "__main__":
+    app()

pa_cli/cli/register_cmd.py

@@ -0,0 +1,32 @@
+import typer
+
+from pa_cli.crawler.account_crawler import AccountCrawler
+from pa_cli.exceptions import AuthError, NetworkError
+
+app = typer.Typer(help="Register a new PythonAnywhere account.")
+
+
+@app.command()
+def register():
+    """Register a new PythonAnywhere account."""
+    username = typer.prompt("Username (letters and numbers only)")
+    email = typer.prompt("Email")
+    password = typer.prompt("Password", hide_input=True)
+    confirm_password = typer.prompt("Confirm password", hide_input=True)
+
+    if password != confirm_password:
+        typer.echo("Passwords do not match.", err=True)
+        raise typer.Exit(code=1)
+
+    try:
+        crawler = AccountCrawler()
+        crawler.register(username, email, password)
+        typer.echo(f"Account '{username}' registered successfully!")
+        typer.echo("Please check your email to verify your account.")
+        typer.echo("Then run: pa init")
+    except AuthError as e:
+        typer.echo(f"Registration failed: {e}", err=True)
+        raise typer.Exit(code=1)
+    except NetworkError as e:
+        typer.echo(f"Network error: {e}", err=True)
+        raise typer.Exit(code=1)