pythonanywhere-clis 1.0.0__py3-none-any.whl

pa_cli/cli/status_cmd.py

@@ -0,0 +1,59 @@
+import typer
+
+from pa_cli.api.system import SystemClient
+from pa_cli.cli.utils import get_client
+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="Query system status and resource usage.")
+
+
+@app.command()
+def cpu():
+    """Show CPU usage."""
+    try:
+        account, client = get_client(SystemClient)
+        data = client.get_cpu_usage(account["username"])
+        used = data.get("daily_cpu_total_usage_seconds", 0)
+        limit = data.get("daily_cpu_limit_seconds", 0)
+        reset = data.get("next_reset_time", "N/A")
+        typer.echo(f"CPU Usage:")
+        typer.echo(f"  Used: {used} seconds")
+        typer.echo(f"  Limit: {limit} seconds")
+        typer.echo(f"  Reset: {reset}")
+    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)
+    except NotFoundError as e:
+        typer.echo(f"Not found: {e}", err=True)
+        raise typer.Exit(code=1)
+
+
+@app.command()
+def disk():
+    """Show disk usage."""
+    try:
+        account = Config.load(verbose=True)
+        crawler = AccountCrawler()
+        crawler.login()
+        data = crawler.get_disk_usage(account["username"])
+        used = data.get("used", "N/A")
+        quota = data.get("quota", "N/A")
+        percent = data.get("percent", "N/A")
+        typer.echo(f"Disk Usage:")
+        typer.echo(f"  Used: {used}")
+        typer.echo(f"  Total: {quota}")
+        typer.echo(f"  Usage: {percent}")
+    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)
+    except NotFoundError as e:
+        typer.echo(f"Not found: {e}", err=True)
+        raise typer.Exit(code=1)

pa_cli/cli/tasks_cmd.py

@@ -0,0 +1,137 @@
+import typer
+
+from pa_cli.api.tasks import TasksClient
+from pa_cli.cli.utils import get_client
+from pa_cli.exceptions import AuthError, NetworkError, NotFoundError, APIError
+
+app = typer.Typer(help="Manage scheduled tasks on PythonAnywhere.")
+
+
+@app.command("list")
+def list_tasks():
+    """List all scheduled tasks."""
+    try:
+        account, client = get_client(TasksClient)
+        tasks = client.list(account["username"])
+        if not tasks:
+            typer.echo("No scheduled tasks found.")
+            return
+        for task in tasks:
+            status = "enabled" if task.get("enabled") else "disabled"
+            typer.echo(f"ID: {task['id']}, Command: {task['command']}, "
+                       f"Interval: {task['interval']}, Status: {status}")
+    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)
+    except APIError as e:
+        typer.echo(f"API error: {e}", err=True)
+        raise typer.Exit(code=1)
+
+
+@app.command()
+def create(
+    command: str = typer.Argument(..., help="Command to execute"),
+    interval: str = typer.Option("daily", "--interval", "-i", help="Interval: hourly, daily, weekly, monthly"),
+    hour: int = typer.Option(0, "--hour", "-H", help="Hour to run (0-23)"),
+    minute: int = typer.Option(0, "--minute", "-M", help="Minute to run (0-59)"),
+    description: str = typer.Option("", "--description", "-d", help="Task description"),
+):
+    """Create a new scheduled task."""
+    try:
+        account, client = get_client(TasksClient)
+        task = client.create(
+            account["username"],
+            command=command,
+            interval=interval,
+            hour=hour,
+            minute=minute,
+            description=description,
+        )
+        typer.echo(f"Task created: ID={task['id']}, Command={task['command']}")
+    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)
+    except APIError as e:
+        typer.echo(f"API error: {e}", err=True)
+        raise typer.Exit(code=1)
+
+
+@app.command()
+def delete(
+    task_id: int = typer.Argument(..., help="Task ID to delete"),
+    force: bool = typer.Option(False, "-f", "--force", help="Skip confirmation"),
+):
+    """Delete a scheduled task."""
+    try:
+        account, client = get_client(TasksClient)
+        if not force:
+            confirm = typer.confirm(f"Are you sure you want to delete task {task_id}?")
+            if not confirm:
+                typer.echo("Cancelled.")
+                raise typer.Exit()
+        client.delete(account["username"], task_id)
+        typer.echo(f"Task {task_id} deleted.")
+    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)
+    except NotFoundError as e:
+        typer.echo(f"Task not found: {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 enable(
+    task_id: int = typer.Argument(..., help="Task ID to enable"),
+):
+    """Enable a scheduled task."""
+    try:
+        account, client = get_client(TasksClient)
+        client.update(account["username"], task_id, enabled=True)
+        typer.echo(f"Task {task_id} enabled.")
+    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)
+    except NotFoundError as e:
+        typer.echo(f"Task not found: {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 disable(
+    task_id: int = typer.Argument(..., help="Task ID to disable"),
+):
+    """Disable a scheduled task."""
+    try:
+        account, client = get_client(TasksClient)
+        client.update(account["username"], task_id, enabled=False)
+        typer.echo(f"Task {task_id} disabled.")
+    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)
+    except NotFoundError as e:
+        typer.echo(f"Task not found: {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/utils.py

@@ -0,0 +1,27 @@
+import re
+from typing import Type, TypeVar, Tuple
+
+from pa_cli.config import Config
+from pa_cli.api.client import BaseClient
+
+T = TypeVar("T", bound=BaseClient)
+
+
+def get_client(client_class: Type[T]) -> Tuple[dict, T]:
+    """Load config and create API client."""
+    account = Config.load(verbose=True)
+    client = client_class(token=account["token"], host=account["host"])
+    return account, client
+
+
+def fix_remote_path(path: str) -> str:
+    """Fix paths mangled by Git Bash (MSYS2) path conversion.
+
+    Git Bash converts /home/user/dir to D:/Git/home/user/dir.
+    This function detects and reverses the conversion.
+    """
+    if re.match(r"^[A-Za-z]:/", path):
+        match = re.search(r"(/home/\S+)", path)
+        if match:
+            return match.group(1)
+    return path

pa_cli/cli/webapps_cmd.py

@@ -0,0 +1,262 @@
+import typer
+
+from pa_cli.api.files import FilesClient
+from pa_cli.api.webapps import WebappsClient
+from pa_cli.cli.utils import get_client, fix_remote_path
+from pa_cli.config import Config
+from pa_cli.crawler.account_crawler import AccountCrawler
+from pa_cli.exceptions import AuthError, NetworkError, NotFoundError, APIError
+
+app = typer.Typer(help="Manage web apps on PythonAnywhere.")
+
+
+@app.command()
+def create(
+    domain_name: str = typer.Argument(..., help="Domain name"),
+    python_version: str = typer.Option("python310", "--python", "-p", help="Python version"),
+):
+    """Create a new web app."""
+    account, client = get_client(WebappsClient)
+    client.create(account["username"], domain_name, python_version)
+    typer.echo(f"Webapp {domain_name} created with {python_version}")
+
+
+@app.command()
+def config(
+    domain_name: str = typer.Argument(None, help="Domain name (default: {username}.pythonanywhere.com)"),
+    source_dir: str = typer.Option(None, "--source-dir", "-s", help="Source directory path"),
+    virtualenv: str = typer.Option(None, "--virtualenv", "-v", help="Virtualenv path"),
+    python_version: str = typer.Option(None, "--python-version", "-p", help="Python version (e.g. 3.10, 3.11)"),
+    working_dir: str = typer.Option(None, "--working-dir", "-w", help="Working directory path"),
+):
+    """Configure a web app."""
+    account, client = get_client(WebappsClient)
+    if domain_name is None:
+        domain_name = f"{account['username']}.pythonanywhere.com"
+    kwargs = {}
+    if source_dir:
+        kwargs["source_directory"] = fix_remote_path(source_dir)
+    if virtualenv:
+        kwargs["virtualenv_path"] = fix_remote_path(virtualenv)
+    if python_version:
+        kwargs["python_version"] = python_version
+    if working_dir:
+        kwargs["working_directory"] = fix_remote_path(working_dir)
+    if not kwargs:
+        typer.echo("Error: No configuration specified. Use --source-dir, --virtualenv, --python-version, or --working-dir.", err=True)
+        raise typer.Exit(code=1)
+    client.update(account["username"], domain_name, **kwargs)
+    typer.echo(f"Webapp {domain_name} configured.")
+
+
+@app.command()
+def static(
+    domain_name: str = typer.Argument(..., help="Domain name"),
+    url: str = typer.Option(..., "--url", help="URL prefix"),
+    path: str = typer.Option(..., "--path", help="Directory path"),
+):
+    """Add a static file mapping."""
+    account, client = get_client(WebappsClient)
+    fixed_path = fix_remote_path(path)
+    client.add_static_file(account["username"], domain_name, url=url, path=fixed_path)
+    typer.echo(f"Static mapping added: {url} -> {fixed_path}")
+
+
+@app.command()
+def reload(
+    domain_name: str = typer.Argument(..., help="Domain name"),
+):
+    """Reload a web app."""
+    account, client = get_client(WebappsClient)
+    client.reload(account["username"], domain_name)
+    typer.echo(f"Webapp {domain_name} reloaded.")
+
+
+@app.command("hits")
+def hits(
+    domain_name: str = typer.Argument(None, help="Domain name (default: {username}.pythonanywhere.com)"),
+):
+    """Get web app hit statistics via crawler."""
+    try:
+        account = Config.load(verbose=True)
+        if domain_name is None:
+            domain_name = f"{account['username']}.pythonanywhere.com"
+        crawler = AccountCrawler()
+        crawler.login()
+        data = crawler.get_hits(domain_name)
+        typer.echo(f"Hit statistics for {domain_name}:")
+        for key, value in data.items():
+            typer.echo(f"  {key}: {value}")
+    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)
+    except NotFoundError as e:
+        typer.echo(f"Not found: {e}", err=True)
+        raise typer.Exit(code=1)
+
+
+@app.command("reload-crawler")
+def reload_crawler(
+    domain_name: str = typer.Argument(None, help="Domain name (default: {username}.pythonanywhere.com)"),
+):
+    """Reload a web app via crawler (alternative to API reload)."""
+    try:
+        account = Config.load(verbose=True)
+        if domain_name is None:
+            domain_name = f"{account['username']}.pythonanywhere.com"
+        crawler = AccountCrawler()
+        crawler.login()
+        if crawler.reload_webapp(domain_name):
+            typer.echo(f"Webapp {domain_name} reloaded successfully.")
+        else:
+            typer.echo(f"Failed to reload webapp {domain_name}.", err=True)
+            raise typer.Exit(code=1)
+    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)
+    except NotFoundError as e:
+        typer.echo(f"Not found: {e}", err=True)
+        raise typer.Exit(code=1)
+
+
+@app.command()
+def delete(
+    domain_name: str = typer.Argument(..., help="Domain name"),
+    force: bool = typer.Option(False, "-f", "--force", help="Skip confirmation"),
+):
+    """Delete a web app."""
+    try:
+        account, client = get_client(WebappsClient)
+        if not force:
+            confirm = typer.confirm(f"Are you sure you want to delete {domain_name}?")
+            if not confirm:
+                typer.echo("Cancelled.")
+                raise typer.Exit()
+        client.delete(account["username"], domain_name)
+        typer.echo(f"Webapp {domain_name} deleted.")
+    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)
+    except NotFoundError as e:
+        typer.echo(f"Not found: {e}", err=True)
+        raise typer.Exit(code=1)
+
+
+@app.command()
+def enable(
+    domain_name: str = typer.Argument(..., help="Domain name"),
+):
+    """Enable a web app."""
+    try:
+        account = Config.load(verbose=True)
+        crawler = AccountCrawler()
+        crawler.login()
+        if crawler.enable_webapp(domain_name):
+            typer.echo(f"Webapp {domain_name} enabled.")
+        else:
+            typer.echo(f"Failed to enable webapp {domain_name}.", err=True)
+            raise typer.Exit(code=1)
+    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)
+    except NotFoundError as e:
+        typer.echo(f"Not found: {e}", err=True)
+        raise typer.Exit(code=1)
+
+
+@app.command()
+def disable(
+    domain_name: str = typer.Argument(..., help="Domain name"),
+):
+    """Disable a web app."""
+    try:
+        account = Config.load(verbose=True)
+        crawler = AccountCrawler()
+        crawler.login()
+        if crawler.disable_webapp(domain_name):
+            typer.echo(f"Webapp {domain_name} disabled.")
+        else:
+            typer.echo(f"Failed to disable webapp {domain_name}.", err=True)
+            raise typer.Exit(code=1)
+    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)
+    except NotFoundError as e:
+        typer.echo(f"Not found: {e}", err=True)
+        raise typer.Exit(code=1)
+
+
+@app.command()
+def logs(
+    domain_name: str = typer.Argument(None, help="Domain name (default: {username}.pythonanywhere.com)"),
+    log_type: str = typer.Option("error", "--type", "-t", help="Log type: access, error, or server"),
+    lines: int = typer.Option(50, "--lines", "-n", help="Number of lines to show"),
+):
+    """Show web app logs."""
+    try:
+        account, client = get_client(FilesClient)
+        if domain_name is None:
+            domain_name = f"{account['username']}.pythonanywhere.com"
+
+        # Extract subdomain from domain_name (lowercase)
+        subdomain = domain_name.split(".")[0].lower()
+        log_file = f"/var/log/{subdomain}.pythonanywhere.com.{log_type}.log"
+
+        try:
+            content = client.download(account["username"], log_file)
+            text = content.decode("utf-8", errors="ignore")
+            # Show last N lines
+            all_lines = text.strip().split("\n")
+            for line in all_lines[-lines:]:
+                typer.echo(line)
+        except NotFoundError:
+            typer.echo(f"Log file not found: {log_file}", err=True)
+            raise typer.Exit(code=1)
+    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)
+    except NotFoundError as e:
+        typer.echo(f"Not found: {e}", err=True)
+        raise typer.Exit(code=1)
+
+
+@app.command()
+def ssl(
+    domain_name: str = typer.Argument(None, help="Domain name (default: {username}.pythonanywhere.com)"),
+):
+    """Show SSL certificate information."""
+    try:
+        account, client = get_client(WebappsClient)
+        if domain_name is None:
+            domain_name = f"{account['username']}.pythonanywhere.com"
+        data = client.get_ssl_info(account["username"], domain_name)
+        cert_type = data.get("cert_type", "N/A")
+        typer.echo(f"SSL Certificate Info for {domain_name}:")
+        typer.echo(f"  Type: {cert_type}")
+    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)
+    except NotFoundError as e:
+        typer.echo(f"Not found: {e}", err=True)
+        raise typer.Exit(code=1)