pythonanywhere-clis 1.0.0__tar.gz

pythonanywhere_clis-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 pythonanywhere-cli contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pythonanywhere_clis-1.0.0/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: pythonanywhere-clis
+Version: 1.0.0
+Summary: CLI tool for automating PythonAnywhere deployments
+Requires-Python: >=3.10
+License-File: LICENSE
+Requires-Dist: typer>=0.9.0
+Requires-Dist: requests>=2.28.0
+Requires-Dist: beautifulsoup4>=4.12.0
+Requires-Dist: websocket-client>=1.6.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-mock>=3.10; extra == "dev"
+Dynamic: license-file

pythonanywhere_clis-1.0.0/README.md

@@ -0,0 +1,262 @@
+# pythonanywhere-cli
+
+CLI tool for automating PythonAnywhere deployments. **Local project → Live website, one step.**
+
+## Installation
+
+```bash
+pip install -e .
+```
+
+## Quick Start
+
+```bash
+# 1. Register a new account (if needed)
+pa register
+
+# 2. Configure your account (auto-fetches API token)
+pa init
+
+# 3. Deploy a project
+pa deploy ./my-site
+```
+
+## Commands
+
+### Account Management
+
+| Command | Description | Auth |
+|---------|-------------|------|
+| `pa init` | Configure account (auto-fetches token) | - |
+| `pa register` | Register a new PythonAnywhere account | - |
+| `pa account list` | List all configured accounts | - |
+| `pa account switch <username>` | Switch default account | - |
+| `pa account remove <username>` | Remove an account | - |
+| `pa account login` | Store password for crawler operations | - |
+| `pa account token` | Fetch API token from account page | Password |
+| `pa account extend` | Extend free tier account expiry | Password |
+
+### File Management
+
+| Command | Description | Auth |
+|---------|-------------|------|
+| `pa files ls [path]` | List remote directory contents | Token |
+| `pa files download <remote> [local]` | Download a file | Token |
+| `pa files download <remote> [local] -r` | Download directory recursively | Token |
+| `pa files rm <path>` | Delete a remote file | Token |
+| `pa files rm <path> -r` | Delete directory recursively | Token |
+| `pa files upload <local> <remote>` | Upload a single file | Token |
+| `pa files upload <local> <remote> -r` | Upload directory recursively | Token |
+| `pa files share <path>` | Share a file and get link | Token |
+| `pa files unshare <path>` | Stop sharing a file | Token |
+| `pa files share-status <path>` | Check if a file is shared | Token |
+
+### Console Management
+
+| Command | Description | Auth |
+|---------|-------------|------|
+| `pa console list` | List all consoles | Token |
+| `pa console create` | Create a new console | Token |
+| `pa console send <id> <cmd>` | Send command and get output | Token |
+| `pa console kill <id>` | Kill a console | Token |
+| `pa console activate <id>` | Activate console via WebSocket | Password |
+| `pa console get-or-create` | Get existing or create new console | Password |
+
+### Web App Management
+
+| Command | Description | Auth |
+|---------|-------------|------|
+| `pa webapp create <domain>` | Create a web app | Token |
+| `pa webapp config <domain> --source-dir <path>` | Configure source directory | Token |
+| `pa webapp config <domain> --virtualenv <path>` | Configure virtualenv path | Token |
+| `pa webapp static <domain> --url <url> --path <path>` | Add static file mapping | Token |
+| `pa webapp reload <domain>` | Reload web app (API) | Token |
+| `pa webapp reload-crawler <domain>` | Reload web app (crawler) | Password |
+| `pa webapp hits <domain>` | Get hit statistics | Password |
+| `pa webapp delete <domain>` | Delete a web app | Token |
+| `pa webapp enable <domain>` | Enable a web app | Token |
+| `pa webapp disable <domain>` | Disable a web app | Token |
+| `pa webapp logs <domain>` | Show web app logs | Token |
+| `pa webapp ssl <domain>` | Show SSL certificate info | Token |
+
+### Deployment
+
+| Command | Description | Auth |
+|---------|-------------|------|
+| `pa deploy <dir>` | One-click deploy to default domain | Token |
+| `pa deploy <dir> --domain <domain>` | One-click deploy to custom domain | Token |
+
+### System Status
+
+| Command | Description | Auth |
+|---------|-------------|------|
+| `pa status cpu` | Show CPU usage | Token |
+| `pa status disk` | Show disk usage | Password |
+
+### Scheduled Tasks
+
+| Command | Description | Auth |
+|---------|-------------|------|
+| `pa tasks list` | List all scheduled tasks | Token |
+| `pa tasks create <command>` | Create a new scheduled task | Token |
+| `pa tasks delete <id>` | Delete a scheduled task | Token |
+| `pa tasks enable <id>` | Enable a scheduled task | Token |
+| `pa tasks disable <id>` | Disable a scheduled task | Token |
+
+### Always-on Tasks
+
+| Command | Description | Auth |
+|---------|-------------|------|
+| `pa always-on list` | List all always-on tasks | Token |
+| `pa always-on create <command>` | Create a new always-on task | Token |
+| `pa always-on delete <id>` | Delete an always-on task | Token |
+
+## Typical Workflows
+
+### Deploy a new project
+
+```bash
+pa init                          # Configure account
+pa deploy ./my-site              # One-click deploy
+```
+
+### Manage existing web app
+
+```bash
+pa webapp reload mysite.pythonanywhere.com           # Reload
+pa webapp hits mysite.pythonanywhere.com             # Check traffic
+pa account extend                                    # Extend expiry
+```
+
+### Work with consoles
+
+```bash
+pa console list                  # See available consoles
+pa console get-or-create        # Get or create a console
+pa console activate 12345       # Activate it
+pa console send 12345 "ls -la"  # Run a command
+pa console kill 12345           # Clean up
+```
+
+### Manage multiple accounts
+
+```bash
+pa init                          # Add first account
+pa init                          # Add second account (becomes default)
+pa account list                  # See all accounts
+pa account switch user1          # Switch back to first
+pa deploy ./site                 # Deploys under user1
+pa account remove user2          # Remove an account
+```
+
+## Configuration
+
+Configuration is stored at `~/.pa-cli/config.json`:
+
+```json
+{
+  "accounts": [
+    {
+      "username": "yourusername",
+      "token": "your-api-token",
+      "host": "www.pythonanywhere.com",
+      "password": "your-password"
+    }
+  ],
+  "default_account": "yourusername"
+}
+```
+
+## Architecture
+
+```
+pa_cli/
+├── api/           # REST API clients (Token auth)
+│   ├── client.py  # BaseClient with Token auth
+│   ├── consoles.py
+│   ├── files.py
+│   ├── webapps.py
+│   ├── system.py
+│   ├── tasks.py
+│   └── always_on.py
+├── cli/           # CLI commands (Typer)
+│   ├── main.py
+│   ├── utils.py   # Shared utilities (get_client, _fix_remote_path)
+│   ├── init_cmd.py
+│   ├── register_cmd.py
+│   ├── account_cmd.py
+│   ├── files_cmd.py
+│   ├── consoles_cmd.py
+│   ├── webapps_cmd.py
+│   ├── deploy_cmd.py
+│   ├── status_cmd.py
+│   ├── tasks_cmd.py
+│   └── always_on_cmd.py
+├── crawler/       # Browser simulation (Session auth)
+│   ├── account_crawler.py
+│   └── console_crawler.py
+├── workflows/     # Deployment orchestration
+│   └── deploy.py
+├── config.py      # Configuration management
+└── exceptions.py  # Exception hierarchy
+```
+
+## Dependencies
+
+- `typer` - CLI framework
+- `requests` - HTTP client
+- `beautifulsoup4` - HTML parsing
+- `websocket-client` - WebSocket connections
+
+## Testing
+
+```bash
+# Run all tests
+pytest
+
+# Run with verbose output
+pytest -v
+
+# Run specific test file
+pytest tests/test_account_crawler.py
+```
+
+**Test coverage:** 267+ tests passing
+
+## Roadmap
+
+### ✅ Completed (P0/P1)
+
+- [x] Account configuration (`pa init`)
+- [x] Account registration (`pa register`)
+- [x] Auto-fetch API token (`pa account token`)
+- [x] Auto-extend expiry (`pa account extend`)
+- [x] File upload (`pa files upload`)
+- [x] File browsing (`pa files ls`)
+- [x] File download (`pa files download`)
+- [x] File deletion (`pa files rm`)
+- [x] Console management (`pa console *`)
+- [x] Web app management (`pa webapp *`)
+- [x] One-click deployment (`pa deploy`)
+- [x] Hit statistics (`pa webapp hits`)
+- [x] Multi-account management (`pa account switch`)
+- [x] CPU usage query (`pa status cpu`)
+- [x] Disk usage query (`pa status disk`)
+
+### ✅ Completed (P2)
+
+- [x] Log management (`pa webapp logs`)
+- [x] Webapp enable/disable (`pa webapp enable/disable`)
+- [x] Delete webapp (`pa webapp delete`)
+- [x] File sharing (`pa files share/unshare/share-status`)
+- [x] SSL info (`pa webapp ssl`)
+- [x] Scheduled tasks (`pa tasks`)
+- [x] Always-on tasks (`pa always-on`)
+
+### 🔲 Planned (P3)
+
+- [ ] Database info (`pa databases`) - API only supports listing, not create/delete
+
+## License
+
+MIT

pythonanywhere_clis-1.0.0/pa_cli/__init__.py

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

pythonanywhere_clis-1.0.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)

pythonanywhere_clis-1.0.0/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

pythonanywhere_clis-1.0.0/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,
+        )

pythonanywhere_clis-1.0.0/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"]

pythonanywhere_clis-1.0.0/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()

pythonanywhere_clis-1.0.0/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)

pythonanywhere_clis-1.0.0/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()