plato-sdk-v2 2.6.1__tar.gz → 2.7.0__tar.gz

{plato_sdk_v2-2.6.1 → plato_sdk_v2-2.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plato-sdk-v2
-Version: 2.6.1
+Version: 2.7.0
 Summary: Python SDK for the Plato API
 Author-email: Plato <support@plato.so>
 License-Expression: MIT

plato_sdk_v2-2.7.0/VERSION

@@ -0,0 +1 @@
+2.7.0

plato_sdk_v2-2.7.0/examples/test.py

@@ -0,0 +1,236 @@
+"""Simple example of creating two VMs from resources with a network.
+
+This script demonstrates:
+1. Creating a Plato session with two VMs from resources
+2. Waiting for VMs to be ready (worker allocation)
+3. Connecting VMs to WireGuard network via connect_network endpoint
+4. Testing VM-to-VM TCP connectivity with Redis over WireGuard
+
+Run with: python test.py
+Requires: PLATO_API_KEY environment variable
+"""
+
+import logging
+import os
+import time
+
+from dotenv import load_dotenv
+
+from plato.v2 import Env, Plato
+from plato.v2.types import SimConfigCompute
+
+load_dotenv()
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+logger = logging.getLogger(__name__)
+
+
+def main():
+    # Check for API key
+    if not os.environ.get("PLATO_API_KEY"):
+        logger.error("PLATO_API_KEY environment variable not set")
+        return
+
+    plato = Plato()
+    session = None
+
+    try:
+        logger.info("=" * 60)
+        logger.info("WIREGUARD NETWORK TCP (REDIS) CONNECTIVITY TEST")
+        logger.info("=" * 60)
+
+        # 1. Define resource configurations for the VMs
+        vm1_config = SimConfigCompute(cpus=2, memory=4096, disk=10000)
+        vm2_config = SimConfigCompute(cpus=2, memory=4096, disk=10000)
+
+        # 2. Create session with two VMs from resources
+        logger.info("[1/8] Creating session with two VMs...")
+        session = plato.sessions.create(
+            envs=[
+                Env.resource("vm1", sim_config=vm1_config, alias="vm1"),
+                Env.resource("vm2", sim_config=vm2_config, alias="vm2"),
+            ],
+            timeout=600,
+        )
+
+        logger.info(f"Session created: {session.session_id}")
+        logger.info(f"Environments: {len(session.envs)}")
+
+        # Get env references
+        vm1 = session.envs[0] if session.envs[0].alias == "vm1" else session.envs[1]
+        vm2 = session.envs[1] if session.envs[0].alias == "vm1" else session.envs[0]
+
+        for env in session.envs:
+            logger.info(f"  - {env.alias}: job_id={env.job_id}")
+
+        # 3. Connect VMs to WireGuard network
+        logger.info("[2/8] Connecting VMs to WireGuard network...")
+
+        connect_result = session.connect_network()
+        logger.info(f"  Network connected: success={connect_result.get('success')}")
+        logger.info(f"  Subnet: {connect_result.get('subnet')}")
+        for job_id, success in connect_result.get("results", {}).items():
+            logger.info(f"    {job_id}: {'OK' if success else 'FAILED'}")
+
+        # 4. Get WireGuard IPs
+        logger.info("[3/8] Getting WireGuard IPs...")
+
+        vm1_wg_ip = vm1.execute("ip -4 addr show wg0 | grep inet | awk '{print $2}' | cut -d/ -f1").stdout.strip()
+        vm2_wg_ip = vm2.execute("ip -4 addr show wg0 | grep inet | awk '{print $2}' | cut -d/ -f1").stdout.strip()
+
+        logger.info(f"  vm1 WireGuard IP: {vm1_wg_ip}")
+        logger.info(f"  vm2 WireGuard IP: {vm2_wg_ip}")
+
+        # 5. Install Redis on both VMs
+        logger.info("[4/8] Installing Redis on VMs...")
+
+        # Install Redis on vm1
+        logger.info("  Installing Redis on vm1...")
+        vm1.execute("apt-get update -qq && apt-get install -y -qq redis-server", timeout=120)
+
+        # Install Redis on vm2
+        logger.info("  Installing Redis on vm2...")
+        vm2.execute("apt-get update -qq && apt-get install -y -qq redis-server", timeout=120)
+
+        # 6. Configure and start Redis servers
+        logger.info("[5/8] Configuring and starting Redis servers...")
+
+        # Configure Redis on vm1 to bind to all interfaces
+        vm1.execute("sed -i 's/^bind 127.0.0.1/bind 0.0.0.0/' /etc/redis/redis.conf")
+        vm1.execute("sed -i 's/^protected-mode yes/protected-mode no/' /etc/redis/redis.conf")
+        vm1.execute("systemctl restart redis-server")
+        logger.info("  Redis started on vm1 (port 6379)")
+
+        # Configure Redis on vm2 to bind to all interfaces
+        vm2.execute("sed -i 's/^bind 127.0.0.1/bind 0.0.0.0/' /etc/redis/redis.conf")
+        vm2.execute("sed -i 's/^protected-mode yes/protected-mode no/' /etc/redis/redis.conf")
+        vm2.execute("systemctl restart redis-server")
+        logger.info("  Redis started on vm2 (port 6379)")
+
+        # Give Redis time to start
+        time.sleep(2)
+
+        # Verify Redis is running locally
+        vm1_redis_check = vm1.execute("redis-cli ping")
+        vm2_redis_check = vm2.execute("redis-cli ping")
+
+        if "PONG" in vm1_redis_check.stdout:
+            logger.info("  OK: vm1 Redis responding locally")
+        else:
+            logger.error(f"  FAIL: vm1 Redis not responding: {vm1_redis_check.stdout}")
+            return
+
+        if "PONG" in vm2_redis_check.stdout:
+            logger.info("  OK: vm2 Redis responding locally")
+        else:
+            logger.error(f"  FAIL: vm2 Redis not responding: {vm2_redis_check.stdout}")
+            return
+
+        # 7. Set keys on each Redis
+        logger.info("[6/8] Setting Redis keys...")
+
+        vm1.execute("redis-cli SET hostname vm1")
+        vm1.execute("redis-cli SET message 'Hello from VM1'")
+        logger.info("  Set keys on vm1: hostname=vm1, message='Hello from VM1'")
+
+        vm2.execute("redis-cli SET hostname vm2")
+        vm2.execute("redis-cli SET message 'Hello from VM2'")
+        logger.info("  Set keys on vm2: hostname=vm2, message='Hello from VM2'")
+
+        # 8. Test TCP connectivity - connect to remote Redis over WireGuard
+        logger.info("[7/8] Testing TCP connectivity (Redis over WireGuard)...")
+
+        # Test vm1 -> vm2's Redis
+        logger.info(f"  Testing TCP from vm1 to vm2 Redis ({vm2_wg_ip}:6379)...")
+
+        vm1_to_vm2_ping = vm1.execute(f"redis-cli -h {vm2_wg_ip} ping")
+        vm1_to_vm2_hostname = vm1.execute(f"redis-cli -h {vm2_wg_ip} GET hostname")
+        vm1_to_vm2_message = vm1.execute(f"redis-cli -h {vm2_wg_ip} GET message")
+
+        if "PONG" in vm1_to_vm2_ping.stdout:
+            logger.info("  OK: vm1 -> vm2 Redis PING successful")
+        else:
+            logger.error(f"  FAIL: vm1 -> vm2 Redis PING failed: {vm1_to_vm2_ping.stdout} {vm1_to_vm2_ping.stderr}")
+
+        if "vm2" in vm1_to_vm2_hostname.stdout:
+            logger.info(f"  OK: vm1 -> vm2 Redis GET hostname = {vm1_to_vm2_hostname.stdout.strip()}")
+        else:
+            logger.error(f"  FAIL: vm1 -> vm2 Redis GET hostname failed: {vm1_to_vm2_hostname.stdout}")
+
+        if "Hello from VM2" in vm1_to_vm2_message.stdout:
+            logger.info(f"  OK: vm1 -> vm2 Redis GET message = {vm1_to_vm2_message.stdout.strip()}")
+        else:
+            logger.error(f"  FAIL: vm1 -> vm2 Redis GET message failed: {vm1_to_vm2_message.stdout}")
+
+        # Test vm2 -> vm1's Redis
+        logger.info(f"  Testing TCP from vm2 to vm1 Redis ({vm1_wg_ip}:6379)...")
+
+        vm2_to_vm1_ping = vm2.execute(f"redis-cli -h {vm1_wg_ip} ping")
+        vm2_to_vm1_hostname = vm2.execute(f"redis-cli -h {vm1_wg_ip} GET hostname")
+        vm2_to_vm1_message = vm2.execute(f"redis-cli -h {vm1_wg_ip} GET message")
+
+        if "PONG" in vm2_to_vm1_ping.stdout:
+            logger.info("  OK: vm2 -> vm1 Redis PING successful")
+        else:
+            logger.error(f"  FAIL: vm2 -> vm1 Redis PING failed: {vm2_to_vm1_ping.stdout} {vm2_to_vm1_ping.stderr}")
+
+        if "vm1" in vm2_to_vm1_hostname.stdout:
+            logger.info(f"  OK: vm2 -> vm1 Redis GET hostname = {vm2_to_vm1_hostname.stdout.strip()}")
+        else:
+            logger.error(f"  FAIL: vm2 -> vm1 Redis GET hostname failed: {vm2_to_vm1_hostname.stdout}")
+
+        if "Hello from VM1" in vm2_to_vm1_message.stdout:
+            logger.info(f"  OK: vm2 -> vm1 Redis GET message = {vm2_to_vm1_message.stdout.strip()}")
+        else:
+            logger.error(f"  FAIL: vm2 -> vm1 Redis GET message failed: {vm2_to_vm1_message.stdout}")
+
+        # 9. Test ping connectivity as sanity check
+        logger.info("[8/8] Testing ping connectivity...")
+
+        ping_result = vm1.execute(f"ping -c 3 -W 5 {vm2_wg_ip}")
+        if ping_result.exit_code == 0:
+            logger.info("  OK: vm1 -> vm2 ping successful!")
+        else:
+            logger.error("  FAIL: vm1 -> vm2 ping failed!")
+
+        # Summary
+        logger.info("")
+        logger.info("=" * 60)
+        logger.info("TEST SUMMARY")
+        logger.info("=" * 60)
+        logger.info(f"Session ID: {session.session_id}")
+        logger.info(f"vm1 WireGuard IP: {vm1_wg_ip}")
+        logger.info(f"vm2 WireGuard IP: {vm2_wg_ip}")
+
+        # Final connectivity check
+        tcp_ok = (
+            "PONG" in vm1_to_vm2_ping.stdout
+            and "vm2" in vm1_to_vm2_hostname.stdout
+            and "PONG" in vm2_to_vm1_ping.stdout
+            and "vm1" in vm2_to_vm1_hostname.stdout
+        )
+
+        if tcp_ok:
+            logger.info("RESULT: WireGuard TCP (Redis) connectivity WORKING!")
+        else:
+            logger.error("RESULT: WireGuard TCP (Redis) connectivity FAILED!")
+
+        logger.info("=" * 60)
+
+    except Exception as e:
+        logger.error(f"ERROR: {e}")
+        import traceback
+
+        traceback.print_exc()
+        raise
+
+    finally:
+        if session:
+            logger.info("Closing session...")
+            session.close()
+        plato.close()
+        logger.info("Cleanup complete.")
+
+
+if __name__ == "__main__":
+    main()

plato_sdk_v2-2.7.0/examples/test_proxy_ssh.py

@@ -0,0 +1,152 @@
+#!/usr/bin/env python3
+"""Test SSH via WireGuard proxy gateway.
+
+Creates a blank VM, connects it to the WireGuard network, and tests SSH access
+through the proxy gateway.
+
+Usage:
+    export PLATO_API_KEY=your-key
+    export PLATO_PROXY_HOST=gateway.plato.so
+    export PLATO_PROXY_PORT=443
+    python test_proxy_ssh.py
+"""
+
+import logging
+import os
+import subprocess
+import sys
+import time
+
+from dotenv import load_dotenv
+
+from plato.v2 import Env, Plato
+from plato.v2.types import SimConfigCompute
+
+load_dotenv()
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
+logger = logging.getLogger(__name__)
+
+
+def test_ssh_connection(job_id: str, proxy_host: str, proxy_port: int) -> bool:
+    """Test SSH connection via proxy gateway."""
+    sni = f"{job_id}--22.{proxy_host}"
+
+    # Use openssl s_client to test TLS connection
+    cmd = ["openssl", "s_client", "-connect", f"{proxy_host}:{proxy_port}", "-servername", sni, "-verify_quiet"]
+
+    logger.info(f"Testing TLS connection to {proxy_host}:{proxy_port} with SNI={sni}")
+
+    try:
+        result = subprocess.run(cmd, input=b"", capture_output=True, timeout=10)
+        if b"CONNECTED" in result.stderr or result.returncode == 0:
+            logger.info("TLS connection successful!")
+            return True
+        else:
+            logger.error(f"TLS connection failed: {result.stderr.decode()[:200]}")
+            return False
+    except subprocess.TimeoutExpired:
+        logger.error("TLS connection timed out")
+        return False
+    except Exception as e:
+        logger.error(f"TLS connection error: {e}")
+        return False
+
+
+def main():
+    # Check environment
+    api_key = os.environ.get("PLATO_API_KEY")
+    if not api_key:
+        logger.error("PLATO_API_KEY not set")
+        return 1
+
+    proxy_host = os.environ.get("PLATO_PROXY_HOST", "gateway.plato.so")
+    proxy_port = int(os.environ.get("PLATO_PROXY_PORT", "443"))
+
+    logger.info("=" * 60)
+    logger.info("WIREGUARD PROXY SSH TEST")
+    logger.info("=" * 60)
+    logger.info(f"Proxy: {proxy_host}:{proxy_port}")
+
+    plato = Plato()
+    session = None
+
+    try:
+        # 1. Create blank VM
+        logger.info("[1/4] Creating blank VM...")
+        vm_config = SimConfigCompute(cpus=2, memory=2048, disk=10000)
+
+        session = plato.sessions.create(
+            envs=[Env.resource("test-vm", sim_config=vm_config, alias="test-vm")],
+            timeout=600,
+        )
+
+        job_id = session.envs[0].job_id
+        logger.info(f"  Session: {session.session_id}")
+        logger.info(f"  Job ID:  {job_id}")
+
+        # 2. Connect to WireGuard network
+        logger.info("[2/4] Connecting to WireGuard network...")
+        result = session.connect_network()
+
+        success = result.get("success", False)
+        subnet = result.get("subnet", "unknown")
+
+        logger.info(f"  Success: {success}")
+        logger.info(f"  Subnet:  {subnet}")
+
+        if not success:
+            logger.error("Failed to connect network!")
+            return 1
+
+        # 3. Get WireGuard IP from VM
+        logger.info("[3/4] Getting VM WireGuard IP...")
+        vm = session.envs[0]
+        wg_ip = vm.execute("ip -4 addr show wg0 | grep inet | awk '{print $2}' | cut -d/ -f1").stdout.strip()
+        logger.info(f"  VM WireGuard IP: {wg_ip}")
+
+        # 4. Test SSH via proxy
+        logger.info("[4/4] Testing SSH via proxy gateway...")
+        ssh_ok = test_ssh_connection(job_id, proxy_host, proxy_port)
+
+        # Summary
+        logger.info("")
+        logger.info("=" * 60)
+        logger.info("RESULTS")
+        logger.info("=" * 60)
+        logger.info(f"Job ID:       {job_id}")
+        logger.info(f"WireGuard IP: {wg_ip}")
+        logger.info(f"SSH Test:     {'PASS' if ssh_ok else 'FAIL'}")
+        logger.info("")
+        logger.info("To SSH manually:")
+        logger.info(f"  export PLATO_PROXY_HOST={proxy_host}")
+        logger.info(f"  export PLATO_PROXY_PORT={proxy_port}")
+        logger.info(f"  plato ssh {job_id} --no-verify")
+        logger.info("")
+        logger.info("Session alive for 600 seconds. Press Ctrl+C to exit early.")
+        logger.info("=" * 60)
+
+        # Keep alive for manual testing
+        try:
+            time.sleep(600)
+        except KeyboardInterrupt:
+            logger.info("\nInterrupted")
+
+        return 0 if ssh_ok else 1
+
+    except Exception as e:
+        logger.error(f"Error: {e}")
+        import traceback
+
+        traceback.print_exc()
+        return 1
+
+    finally:
+        if session:
+            logger.info("Closing session...")
+            session.close()
+        plato.close()
+
+
+if __name__ == "__main__":
+    sys.exit(main())

{plato_sdk_v2-2.6.1 → plato_sdk_v2-2.7.0}/plato/_generated/__init__.py

@@ -1,4 +1,4 @@
-"""Plato API SDK - v0.41.4"""
+"""Plato API SDK - v0.37.2"""
 
 from . import api, errors, models
 from .client import AsyncClient, Client

{plato_sdk_v2-2.6.1 → plato_sdk_v2-2.7.0}/plato/_generated/api/v2/__init__.py

@@ -1,6 +1,6 @@
 """API version module."""
 
-from . import agents, artifacts, chronos, chronos_packages, cluster, jobs, pypi, releases, sessions, user
+from . import agents, artifacts, chronos, chronos_packages, cluster, jobs, networks, pypi, releases, sessions, user
 
 __all__ = [
     "agents",
@@ -9,6 +9,7 @@ __all__ = [
     "chronos_packages",
     "cluster",
     "jobs",
+    "networks",
     "pypi",
     "releases",
     "sessions",

plato_sdk_v2-2.7.0/plato/_generated/api/v2/networks/__init__.py

@@ -0,0 +1,23 @@
+"""API endpoints."""
+
+from . import (
+    add_member,
+    create_network,
+    delete_network,
+    get_network,
+    list_members,
+    list_networks,
+    remove_member,
+    update_member,
+)
+
+__all__ = [
+    "list_networks",
+    "create_network",
+    "get_network",
+    "delete_network",
+    "list_members",
+    "add_member",
+    "update_member",
+    "remove_member",
+]

plato_sdk_v2-2.7.0/plato/_generated/api/v2/networks/add_member.py

@@ -0,0 +1,75 @@
+"""Add Member"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+from plato._generated.errors import raise_for_status
+from plato._generated.models import AddMemberRequest, NetworkMemberResponse
+
+
+def _build_request_args(
+    session_id: str,
+    body: AddMemberRequest,
+    authorization: str | None = None,
+    x_api_key: str | None = None,
+) -> dict[str, Any]:
+    """Build request arguments."""
+    url = f"/api/v2/networks/{session_id}/members"
+
+    headers: dict[str, str] = {}
+    if authorization is not None:
+        headers["authorization"] = authorization
+    if x_api_key is not None:
+        headers["X-API-Key"] = x_api_key
+
+    return {
+        "method": "POST",
+        "url": url,
+        "json": body.model_dump(mode="json", exclude_none=True),
+        "headers": headers,
+    }
+
+
+def sync(
+    client: httpx.Client,
+    session_id: str,
+    body: AddMemberRequest,
+    authorization: str | None = None,
+    x_api_key: str | None = None,
+) -> NetworkMemberResponse:
+    """Add a member (job/VM) to a network."""
+
+    request_args = _build_request_args(
+        session_id=session_id,
+        body=body,
+        authorization=authorization,
+        x_api_key=x_api_key,
+    )
+
+    response = client.request(**request_args)
+    raise_for_status(response)
+    return NetworkMemberResponse.model_validate(response.json())
+
+
+async def asyncio(
+    client: httpx.AsyncClient,
+    session_id: str,
+    body: AddMemberRequest,
+    authorization: str | None = None,
+    x_api_key: str | None = None,
+) -> NetworkMemberResponse:
+    """Add a member (job/VM) to a network."""
+
+    request_args = _build_request_args(
+        session_id=session_id,
+        body=body,
+        authorization=authorization,
+        x_api_key=x_api_key,
+    )
+
+    response = await client.request(**request_args)
+    raise_for_status(response)
+    return NetworkMemberResponse.model_validate(response.json())

plato_sdk_v2-2.7.0/plato/_generated/api/v2/networks/create_network.py

@@ -0,0 +1,70 @@
+"""Create Network"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+from plato._generated.errors import raise_for_status
+from plato._generated.models import CreateNetworkRequest, CreateNetworkResponse
+
+
+def _build_request_args(
+    body: CreateNetworkRequest,
+    authorization: str | None = None,
+    x_api_key: str | None = None,
+) -> dict[str, Any]:
+    """Build request arguments."""
+    url = "/api/v2/networks/"
+
+    headers: dict[str, str] = {}
+    if authorization is not None:
+        headers["authorization"] = authorization
+    if x_api_key is not None:
+        headers["X-API-Key"] = x_api_key
+
+    return {
+        "method": "POST",
+        "url": url,
+        "json": body.model_dump(mode="json", exclude_none=True),
+        "headers": headers,
+    }
+
+
+def sync(
+    client: httpx.Client,
+    body: CreateNetworkRequest,
+    authorization: str | None = None,
+    x_api_key: str | None = None,
+) -> CreateNetworkResponse:
+    """Create a new isolated network for a session."""
+
+    request_args = _build_request_args(
+        body=body,
+        authorization=authorization,
+        x_api_key=x_api_key,
+    )
+
+    response = client.request(**request_args)
+    raise_for_status(response)
+    return CreateNetworkResponse.model_validate(response.json())
+
+
+async def asyncio(
+    client: httpx.AsyncClient,
+    body: CreateNetworkRequest,
+    authorization: str | None = None,
+    x_api_key: str | None = None,
+) -> CreateNetworkResponse:
+    """Create a new isolated network for a session."""
+
+    request_args = _build_request_args(
+        body=body,
+        authorization=authorization,
+        x_api_key=x_api_key,
+    )
+
+    response = await client.request(**request_args)
+    raise_for_status(response)
+    return CreateNetworkResponse.model_validate(response.json())

plato_sdk_v2-2.7.0/plato/_generated/api/v2/networks/delete_network.py

@@ -0,0 +1,68 @@
+"""Delete Network"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+from plato._generated.errors import raise_for_status
+
+
+def _build_request_args(
+    session_id: str,
+    authorization: str | None = None,
+    x_api_key: str | None = None,
+) -> dict[str, Any]:
+    """Build request arguments."""
+    url = f"/api/v2/networks/{session_id}"
+
+    headers: dict[str, str] = {}
+    if authorization is not None:
+        headers["authorization"] = authorization
+    if x_api_key is not None:
+        headers["X-API-Key"] = x_api_key
+
+    return {
+        "method": "DELETE",
+        "url": url,
+        "headers": headers,
+    }
+
+
+def sync(
+    client: httpx.Client,
+    session_id: str,
+    authorization: str | None = None,
+    x_api_key: str | None = None,
+) -> dict[str, Any]:
+    """Delete/terminate a network."""
+
+    request_args = _build_request_args(
+        session_id=session_id,
+        authorization=authorization,
+        x_api_key=x_api_key,
+    )
+
+    response = client.request(**request_args)
+    raise_for_status(response)
+    return response.json()
+
+
+async def asyncio(
+    client: httpx.AsyncClient,
+    session_id: str,
+    authorization: str | None = None,
+    x_api_key: str | None = None,
+) -> dict[str, Any]:
+    """Delete/terminate a network."""
+
+    request_args = _build_request_args(
+        session_id=session_id,
+        authorization=authorization,
+        x_api_key=x_api_key,
+    )
+
+    response = await client.request(**request_args)
+    raise_for_status(response)
+    return response.json()