pythonanywhere-clis 1.0.0__py3-none-any.whl

pa_cli/__init__.py

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

pa_cli/api/always_on.py

@@ -0,0 +1,22 @@
+from pa_cli.api.client import BaseClient
+
+
+class AlwaysOnClient(BaseClient):
+    def list(self, username: str) -> list:
+        """List all always-on tasks."""
+        response = self._request("GET", "/api/v0/user/{username}/always_on/", username=username)
+        return response.json()
+
+    def create(self, username: str, command: str, enabled: bool = True) -> dict:
+        """Create a new always-on task."""
+        response = self._request(
+            "POST",
+            "/api/v0/user/{username}/always_on/",
+            username=username,
+            json={"command": command, "enabled": enabled},
+        )
+        return response.json()
+
+    def delete(self, username: str, task_id: int) -> None:
+        """Delete an always-on task."""
+        self._request("DELETE", "/api/v0/user/{username}/always_on/{id}/", username=username, id=task_id)

pa_cli/api/client.py

@@ -0,0 +1,45 @@
+import requests
+
+from pa_cli.exceptions import APIError, NetworkError, NotFoundError
+
+
+class BaseClient:
+    def __init__(self, token: str, host: str = "www.pythonanywhere.com"):
+        self.host = host
+        self.base_url = f"https://{host}"
+        self.session = requests.Session()
+        self.session.headers.update({"Authorization": f"Token {token}"})
+
+    def _build_url(self, path: str, **kwargs) -> str:
+        return f"{self.base_url}{path.format(**kwargs)}"
+
+    def _request(self, method: str, path: str, **kwargs) -> requests.Response:
+        url = self._build_url(path, **kwargs)
+
+        # Extract path params from kwargs (used in URL formatting)
+        path_params = {k for k in kwargs if "{" + k + "}" in path}
+        request_kwargs = {k: v for k, v in kwargs.items() if k not in path_params}
+
+        try:
+            response = self.session.request(method, url, **request_kwargs)
+        except requests.ConnectionError as e:
+            raise NetworkError(f"Connection failed: {e}") from e
+        except requests.Timeout as e:
+            raise NetworkError(f"Request timed out: {e}") from e
+        except requests.RequestException as e:
+            raise NetworkError(f"Request failed: {e}") from e
+
+        if response.status_code == 404:
+            raise NotFoundError(f"Not found: {path}")
+
+        try:
+            response.raise_for_status()
+        except requests.HTTPError as e:
+            detail = ""
+            try:
+                detail = response.json().get("detail", "")
+            except Exception:
+                detail = response.text
+            raise APIError(f"API error {response.status_code}: {detail}") from e
+
+        return response

pa_cli/api/consoles.py

@@ -0,0 +1,46 @@
+from pa_cli.api.client import BaseClient
+
+
+class ConsolesClient(BaseClient):
+    def list(self, username: str) -> list:
+        response = self._request(
+            "GET",
+            "/api/v0/user/{username}/consoles/",
+            username=username,
+        )
+        return response.json()
+
+    def create(self, username: str, executable: str = "bash") -> dict:
+        response = self._request(
+            "POST",
+            "/api/v0/user/{username}/consoles/",
+            username=username,
+            json={"executable": executable},
+        )
+        return response.json()
+
+    def send_input(self, username: str, console_id: int, input_text: str) -> None:
+        self._request(
+            "POST",
+            "/api/v0/user/{username}/consoles/{id}/send_input/",
+            username=username,
+            id=console_id,
+            data={"input": input_text},
+        )
+
+    def get_output(self, username: str, console_id: int) -> dict:
+        response = self._request(
+            "GET",
+            "/api/v0/user/{username}/consoles/{id}/get_latest_output/",
+            username=username,
+            id=console_id,
+        )
+        return response.json()
+
+    def kill(self, username: str, console_id: int) -> None:
+        self._request(
+            "DELETE",
+            "/api/v0/user/{username}/consoles/{id}/",
+            username=username,
+            id=console_id,
+        )

pa_cli/api/files.py

@@ -0,0 +1,95 @@
+from pa_cli.api.client import BaseClient
+from pa_cli.exceptions import APIError, NotFoundError
+
+
+class FilesClient(BaseClient):
+    def upload(self, username: str, remote_path: str, content: bytes) -> int:
+        url = self._build_url(
+            "/api/v0/user/{username}/files/path{remote_path}",
+            username=username,
+            remote_path=remote_path,
+        )
+        response = self.session.post(url, files={"content": content})
+        if response.status_code == 404:
+            raise NotFoundError(f"Not found: {remote_path}")
+        try:
+            response.raise_for_status()
+        except Exception as e:
+            raise APIError(f"Upload failed: {response.status_code} {response.text}") from e
+        return response.status_code
+
+    def list(self, username: str, remote_path: str) -> dict:
+        """List files and directories at remote path. Returns dict of {name: {type, url}}."""
+        url = self._build_url(
+            "/api/v0/user/{username}/files/path{remote_path}",
+            username=username,
+            remote_path=remote_path,
+        )
+        response = self.session.get(url)
+        if response.status_code == 404:
+            raise NotFoundError(f"Not found: {remote_path}")
+        try:
+            response.raise_for_status()
+        except Exception as e:
+            raise APIError(f"List failed: {response.status_code} {response.text}") from e
+        return response.json()
+
+    def download(self, username: str, remote_path: str) -> bytes:
+        """Download a file from remote path. Returns file content as bytes."""
+        url = self._build_url(
+            "/api/v0/user/{username}/files/path{remote_path}",
+            username=username,
+            remote_path=remote_path,
+        )
+        response = self.session.get(url)
+        if response.status_code == 404:
+            raise NotFoundError(f"Not found: {remote_path}")
+        try:
+            response.raise_for_status()
+        except Exception as e:
+            raise APIError(f"Download failed: {response.status_code} {response.text}") from e
+        return response.content
+
+    def delete(self, username: str, remote_path: str) -> None:
+        """Delete a file or directory at remote path."""
+        url = self._build_url(
+            "/api/v0/user/{username}/files/path{remote_path}",
+            username=username,
+            remote_path=remote_path,
+        )
+        response = self.session.delete(url)
+        if response.status_code == 404:
+            raise NotFoundError(f"Not found: {remote_path}")
+        try:
+            response.raise_for_status()
+        except Exception as e:
+            raise APIError(f"Delete failed: {response.status_code} {response.text}") from e
+
+    def share(self, username: str, remote_path: str) -> str:
+        """Share a file and return the share URL."""
+        response = self._request(
+            "POST",
+            "/api/v0/user/{username}/files/sharing/",
+            username=username,
+            json={"path": remote_path},
+        )
+        return response.json()["url"]
+
+    def unshare(self, username: str, remote_path: str) -> None:
+        """Stop sharing a file."""
+        self._request(
+            "DELETE",
+            "/api/v0/user/{username}/files/sharing/",
+            username=username,
+            params={"path": remote_path},
+        )
+
+    def get_share_status(self, username: str, remote_path: str) -> str:
+        """Get share status for a file. Returns share URL or raises NotFoundError."""
+        response = self._request(
+            "GET",
+            "/api/v0/user/{username}/files/sharing/",
+            username=username,
+            params={"path": remote_path},
+        )
+        return response.json()["url"]

pa_cli/api/system.py

@@ -0,0 +1,8 @@
+from pa_cli.api.client import BaseClient
+
+
+class SystemClient(BaseClient):
+    def get_cpu_usage(self, username: str) -> dict:
+        """Get CPU usage stats."""
+        response = self._request("GET", "/api/v0/user/{username}/cpu/", username=username)
+        return response.json()

pa_cli/api/tasks.py

@@ -0,0 +1,47 @@
+from pa_cli.api.client import BaseClient
+
+
+class TasksClient(BaseClient):
+    def list(self, username: str) -> list:
+        """List all scheduled tasks."""
+        response = self._request("GET", "/api/v0/user/{username}/schedule/", username=username)
+        return response.json()
+
+    def get(self, username: str, task_id: int) -> dict:
+        """Get a specific scheduled task."""
+        response = self._request("GET", "/api/v0/user/{username}/schedule/{id}/", username=username, id=task_id)
+        return response.json()
+
+    def create(self, username: str, command: str, interval: str = "daily",
+               hour: int = 0, minute: int = 0, enabled: bool = True,
+               description: str = "") -> dict:
+        """Create a new scheduled task."""
+        response = self._request(
+            "POST",
+            "/api/v0/user/{username}/schedule/",
+            username=username,
+            json={
+                "command": command,
+                "interval": interval,
+                "hour": hour,
+                "minute": minute,
+                "enabled": enabled,
+                "description": description,
+            },
+        )
+        return response.json()
+
+    def update(self, username: str, task_id: int, **kwargs) -> dict:
+        """Update a scheduled task."""
+        response = self._request(
+            "PATCH",
+            "/api/v0/user/{username}/schedule/{id}/",
+            username=username,
+            id=task_id,
+            json=kwargs,
+        )
+        return response.json()
+
+    def delete(self, username: str, task_id: int) -> None:
+        """Delete a scheduled task."""
+        self._request("DELETE", "/api/v0/user/{username}/schedule/{id}/", username=username, id=task_id)

pa_cli/api/webapps.py

@@ -0,0 +1,71 @@
+from pa_cli.api.client import BaseClient
+
+
+class WebappsClient(BaseClient):
+    def create(self, username: str, domain_name: str, python_version: str) -> None:
+        self._request(
+            "POST",
+            "/api/v0/user/{username}/webapps/",
+            username=username,
+            data={"domain_name": domain_name, "python_version": python_version},
+        )
+
+    def update(self, username: str, domain_name: str, **kwargs) -> None:
+        self._request(
+            "PUT",
+            "/api/v0/user/{username}/webapps/{domain_name}/",
+            username=username,
+            domain_name=domain_name,
+            json=kwargs,
+        )
+
+    def delete(self, username: str, domain_name: str) -> None:
+        self._request(
+            "DELETE",
+            "/api/v0/user/{username}/webapps/{domain_name}/",
+            username=username,
+            domain_name=domain_name,
+        )
+
+    def enable(self, username: str, domain_name: str) -> None:
+        self._request(
+            "POST",
+            "/api/v0/user/{username}/webapps/{domain_name}/enable/",
+            username=username,
+            domain_name=domain_name,
+        )
+
+    def disable(self, username: str, domain_name: str) -> None:
+        self._request(
+            "POST",
+            "/api/v0/user/{username}/webapps/{domain_name}/disable/",
+            username=username,
+            domain_name=domain_name,
+        )
+
+    def add_static_file(self, username: str, domain_name: str, url: str, path: str) -> None:
+        self._request(
+            "POST",
+            "/api/v0/user/{username}/webapps/{domain_name}/static_files/",
+            username=username,
+            domain_name=domain_name,
+            data={"url": url, "path": path},
+        )
+
+    def reload(self, username: str, domain_name: str) -> None:
+        self._request(
+            "POST",
+            "/api/v0/user/{username}/webapps/{domain_name}/reload/",
+            username=username,
+            domain_name=domain_name,
+        )
+
+    def get_ssl_info(self, username: str, domain_name: str) -> dict:
+        """Get SSL certificate information."""
+        response = self._request(
+            "GET",
+            "/api/v0/user/{username}/webapps/{domain_name}/ssl/",
+            username=username,
+            domain_name=domain_name,
+        )
+        return response.json()

pa_cli/cli/account_cmd.py

@@ -0,0 +1,131 @@
+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="Account management commands.")
+
+
+@app.command()
+def switch(
+    username: str = typer.Argument(..., help="Username to switch to"),
+):
+    """Switch the default account."""
+    try:
+        Config.set_default(username)
+        typer.echo(f"Switched to account '{username}'.")
+    except Exception as e:
+        typer.echo(f"Error: {e}", err=True)
+        raise typer.Exit(code=1)
+
+
+@app.command()
+def remove(
+    username: str = typer.Argument(..., help="Username to remove"),
+):
+    """Remove an account from config."""
+    try:
+        new_default = Config.remove(username)
+        typer.echo(f"Removed account '{username}'.")
+        if new_default:
+            typer.echo(f"Switched to account '{new_default}'.")
+    except Exception as e:
+        typer.echo(f"Error: {e}", err=True)
+        raise typer.Exit(code=1)
+
+
+@app.command("list")
+def list_accounts():
+    """List all configured accounts."""
+    accounts = Config.list_accounts()
+    if not accounts:
+        typer.echo("No accounts configured. Run 'pa init' to add one.")
+        return
+
+    try:
+        current = Config.load(verbose=True)
+        current_user = current["username"]
+    except (FileNotFoundError, ValueError):
+        current_user = ""
+
+    for account in accounts:
+        prefix = "* " if account["username"] == current_user else "  "
+        token = account.get("token", "")
+        token_display = f"token: {token[:8]}..." if token else "(no token)"
+        host = account.get("host", "www.pythonanywhere.com")
+        typer.echo(f"{prefix}{account['username']}    {host}    {token_display}")
+
+
+@app.command()
+def login():
+    """Store password for the current account."""
+    password = typer.prompt("Password", hide_input=True)
+    Config.save(password=password)
+    typer.echo("Password saved successfully.")
+
+
+@app.command()
+def token(
+    revoke: bool = typer.Option(False, "--revoke", "-r", help="Revoke current token and create a new one"),
+):
+    """Get API token. Creates one automatically if none exists. Use --revoke to force refresh."""
+    try:
+        crawler = AccountCrawler()
+        crawler.login()
+        typer.echo(f"[account: {crawler.username}]")
+
+        if revoke:
+            new_token = crawler.create_token()
+            Config.save(token=new_token)
+            typer.echo(f"Token revoked. New token: {new_token}")
+        else:
+            try:
+                existing = crawler.get_token()
+                Config.save(token=existing)
+                typer.echo(f"API token: {existing}")
+            except NotFoundError:
+                new_token = crawler.create_token()
+                Config.save(token=new_token)
+                typer.echo(f"Token created: {new_token}")
+    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 extend():
+    """Extend account expiry by logging in via crawler."""
+    try:
+        crawler = AccountCrawler()
+        crawler.login()
+        typer.echo(f"[account: {crawler.username}]")
+
+        current_expiry = crawler.get_expiry_date()
+        if current_expiry:
+            typer.echo(f"Current expiry: {current_expiry}")
+
+        if crawler.extend_expiry():
+            typer.echo("Account expiry extended successfully.")
+            new_expiry = crawler.get_expiry_date()
+            if new_expiry:
+                typer.echo(f"New expiry: {new_expiry}")
+        else:
+            typer.echo("Failed to extend account expiry.", 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)
+

pa_cli/cli/always_on_cmd.py

@@ -0,0 +1,82 @@
+import typer
+
+from pa_cli.api.always_on import AlwaysOnClient
+from pa_cli.cli.utils import get_client
+from pa_cli.exceptions import AuthError, NetworkError, NotFoundError, APIError
+
+app = typer.Typer(help="Manage always-on tasks on PythonAnywhere.")
+
+
+@app.command("list")
+def list_tasks():
+    """List all always-on tasks."""
+    try:
+        account, client = get_client(AlwaysOnClient)
+        tasks = client.list(account["username"])
+        if not tasks:
+            typer.echo("No always-on tasks found.")
+            return
+        for task in tasks:
+            status = "enabled" if task.get("enabled") else "disabled"
+            typer.echo(f"ID: {task['id']}, Command: {task['command']}, 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 run"),
+):
+    """Create a new always-on task."""
+    try:
+        account, client = get_client(AlwaysOnClient)
+        task = client.create(account["username"], command=command)
+        typer.echo(f"Always-on task created: ID={task['id']}, Command={task['command']}")
+    except APIError as e:
+        if "limit" in str(e).lower():
+            typer.echo("Error: Always-on task limit reached. Upgrade your plan to add more.", err=True)
+        else:
+            typer.echo(f"API error: {e}", 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)
+
+
+@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 an always-on task."""
+    try:
+        account, client = get_client(AlwaysOnClient)
+        if not force:
+            confirm = typer.confirm(f"Are you sure you want to delete always-on task {task_id}?")
+            if not confirm:
+                typer.echo("Cancelled.")
+                raise typer.Exit()
+        client.delete(account["username"], task_id)
+        typer.echo(f"Always-on 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)