plato-sdk-v2 2.8.1__tar.gz → 2.8.2__tar.gz

{plato_sdk_v2-2.8.1 → plato_sdk_v2-2.8.2}/PKG-INFO

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

plato_sdk_v2-2.8.2/VERSION

@@ -0,0 +1 @@
+2.8.2

{plato_sdk_v2-2.8.1 → plato_sdk_v2-2.8.2}/plato/cli/pm.py

@@ -22,12 +22,10 @@ from plato._generated.api.v1.simulator import (
     update_simulator_status,
     update_tag,
 )
-from plato._generated.api.v2.sessions import state as sessions_state
 from plato._generated.models import (
     AddReviewRequest,
     AppApiV1SimulatorRoutesUpdateSimulatorRequest,
     Authentication,
-    Flow,
     Outcome,
     ReviewType,
     UpdateStatusRequest,
@@ -42,9 +40,9 @@ from plato.cli.utils import (
     require_sandbox_field,
     require_sandbox_state,
 )
-from plato.v2.async_.client import AsyncPlato
-from plato.v2.async_.flow_executor import FlowExecutor
-from plato.v2.types import Env
+from plato.v1.flow_executor import FlowExecutor
+from plato.v1.models.flow import Flow
+from plato.v1.sdk import Plato
 
 # =============================================================================
 # CONSTANTS
@@ -318,25 +316,30 @@ def review_base(
     )
 
     async def _review_base():
+        import warnings
+
         base_url = _get_base_url()
-        plato = AsyncPlato(api_key=api_key, base_url=base_url)
-        session = None
+        # v1 SDK expects base_url to include /api suffix
+        v1_base_url = f"{base_url}/api"
+        # Suppress the deprecation warning from v1 Plato
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", DeprecationWarning)
+            plato = Plato(api_key=api_key, base_url=v1_base_url)
+        env = None
         playwright = None
         browser = None
-        login_result = None
 
         try:
-            http_client = plato._http
-
             # simulator_name is guaranteed set by parse_simulator_artifact (or we exit)
             assert simulator_name is not None, "simulator_name must be set"
 
-            # Get simulator by name
-            sim = await get_simulator_by_name.asyncio(
-                client=http_client,
-                name=simulator_name,
-                x_api_key=api_key,
-            )
+            # Get simulator by name using httpx for API calls
+            async with httpx.AsyncClient(base_url=base_url, timeout=60.0) as http_client:
+                sim = await get_simulator_by_name.asyncio(
+                    client=http_client,
+                    name=simulator_name,
+                    x_api_key=api_key,
+                )
             simulator_id = sim.id
             current_config = sim.config or {}
             current_status = current_config.get("status", "not_started")
@@ -357,26 +360,27 @@ def review_base(
 
             console.print(f"[cyan]Using artifact:[/cyan] {artifact_id}")
 
-            # Try to create session with environment from artifact
+            # Try to create environment from artifact using v1 API
             try:
                 console.print(f"[cyan]Creating {simulator_name} environment with artifact {artifact_id}...[/cyan]")
-                session = await plato.sessions.create(
-                    envs=[Env.artifact(artifact_id)],
-                    timeout=300,
+                env = await plato.make_environment(
+                    env_id=simulator_name,
+                    artifact_id=artifact_id,
                 )
-                console.print(f"[green]✅ Session created: {session.session_id}[/green]")
+                console.print(f"[green]✅ Environment created: {env.id}[/green]")
+
+                # Wait for environment to be ready
+                console.print("[cyan]Waiting for environment to be ready...[/cyan]")
+                await env.wait_for_ready(timeout=300)
+                console.print("[green]✅ Environment ready![/green]")
 
                 # Reset
                 console.print("[cyan]Resetting environment...[/cyan]")
-                await session.reset()
+                await env.reset()
                 console.print("[green]✅ Environment reset complete![/green]")
 
-                # Get public URL
-                public_urls = await session.get_public_url()
-                first_alias = session.envs[0].alias if session.envs else None
-                public_url = public_urls.get(first_alias) if first_alias else None
-                if not public_url and public_urls:
-                    public_url = list(public_urls.values())[0]
+                # Get public URL (v1 returns string directly)
+                public_url = await env.get_public_url()
                 console.print(f"[cyan]Public URL:[/cyan] {public_url}")
 
                 # Launch Playwright browser and login
@@ -452,70 +456,66 @@ def review_base(
                     except Exception as e:
                         console.print(f"[yellow]⚠️  Flow execution error: {e}[/yellow]")
                 else:
-                    # Use default login via session.login()
+                    # Use default login via env.login() (v1 API takes Page, not Browser)
                     if fake_time:
                         console.print("[yellow]⚠️  --clock with default login may not work correctly.[/yellow]")
                         console.print("[yellow]   Use --local with a flow file for reliable clock testing.[/yellow]")
                     try:
-                        login_result = await session.login(browser, dataset="base")
-                        page = list(login_result.pages.values())[0] if login_result.pages else None
-                        console.print("[green]✅ Logged into environment[/green]")
-                    except Exception as e:
-                        console.print(f"[yellow]⚠️  Login error: {e}[/yellow]")
+                        # Create page and navigate to public URL first
                         page = await browser.new_page()
-                        # Install fake clock on fallback page
                         if fake_time:
                             await page.clock.install(time=fake_time)
                             console.print(f"[green]✅ Fake clock installed: {fake_time.isoformat()}[/green]")
                         if public_url:
                             await page.goto(public_url)
+                        # v1 login takes a Page and uses from_api=True to fetch flows from server
+                        await env.login(page, dataset="base", from_api=True)
+                        console.print("[green]✅ Logged into environment[/green]")
+                    except Exception as e:
+                        console.print(f"[yellow]⚠️  Login error: {e}[/yellow]")
+                        # Page already created above, just navigate if not already done
+                        if public_url and page:
+                            try:
+                                await page.goto(public_url)
+                            except Exception:
+                                pass
 
                 # ALWAYS check state after login to verify no mutations
                 console.print("\n[cyan]Checking environment state after login...[/cyan]")
                 has_mutations = False
                 has_errors = False
                 try:
-                    state_response = await sessions_state.asyncio(
-                        client=http_client,
-                        session_id=session.session_id,
-                        merge_mutations=True,
-                        x_api_key=api_key,
-                    )
-                    if state_response and state_response.results:
-                        for jid, result in state_response.results.items():
-                            state_data = result.state if hasattr(result, "state") else result
-                            console.print(f"\n[bold cyan]Job {jid}:[/bold cyan]")
-
-                            if isinstance(state_data, dict):
-                                # Check for error in state response
-                                if "error" in state_data:
-                                    has_errors = True
-                                    console.print("\n[bold red]❌ State API Error:[/bold red]")
-                                    console.print(f"[red]{state_data['error']}[/red]")
-                                    continue
-
-                                mutations = state_data.pop("mutations", [])
-                                console.print("\n[bold]State:[/bold]")
-                                console.print(json.dumps(state_data, indent=2, default=str))
-                                if mutations:
-                                    has_mutations = True
-                                    console.print(f"\n[bold red]Mutations ({len(mutations)}):[/bold red]")
-                                    console.print(json.dumps(mutations, indent=2, default=str))
-                                else:
-                                    console.print("\n[green]No mutations recorded[/green]")
-                            else:
-                                console.print(f"[yellow]Unexpected state format: {type(state_data)}[/yellow]")
-
-                        if has_errors:
-                            console.print("\n[bold red]❌ State check failed due to errors![/bold red]")
-                            console.print("[yellow]The worker may not be properly connected.[/yellow]")
-                        elif has_mutations:
-                            console.print("\n[bold red]⚠️  WARNING: Login flow created mutations![/bold red]")
-                            console.print("[yellow]The login flow should NOT modify database state.[/yellow]")
+                    # v1 API: env.get_state() returns state dict directly
+                    state_data = await env.get_state(merge_mutations=True)
+                    console.print(f"\n[bold cyan]Environment {env.id}:[/bold cyan]")
+
+                    if isinstance(state_data, dict):
+                        # Check for error in state response (only if error has a truthy value)
+                        if state_data.get("error"):
+                            has_errors = True
+                            console.print("\n[bold red]❌ State API Error:[/bold red]")
+                            console.print(f"[red]{state_data['error']}[/red]")
                         else:
-                            console.print("\n[bold green]✅ Login flow verified - no mutations created[/bold green]")
+                            mutations = state_data.pop("mutations", [])
+                            console.print("\n[bold]State:[/bold]")
+                            console.print(json.dumps(state_data, indent=2, default=str))
+                            if mutations:
+                                has_mutations = True
+                                console.print(f"\n[bold red]Mutations ({len(mutations)}):[/bold red]")
+                                console.print(json.dumps(mutations, indent=2, default=str))
+                            else:
+                                console.print("\n[green]No mutations recorded[/green]")
                     else:
-                        console.print("[yellow]No state data available[/yellow]")
+                        console.print(f"[yellow]Unexpected state format: {type(state_data)}[/yellow]")
+
+                    if has_errors:
+                        console.print("\n[bold red]❌ State check failed due to errors![/bold red]")
+                        console.print("[yellow]The worker may not be properly connected.[/yellow]")
+                    elif has_mutations:
+                        console.print("\n[bold red]⚠️  WARNING: Login flow created mutations![/bold red]")
+                        console.print("[yellow]The login flow should NOT modify database state.[/yellow]")
+                    else:
+                        console.print("\n[bold green]✅ Login flow verified - no mutations created[/bold green]")
                 except Exception as e:
                     console.print(f"[red]❌ Error getting state: {e}[/red]")
 
@@ -562,37 +562,26 @@ def review_base(
                         elif command in ["state", "s"]:
                             console.print("\n[cyan]Getting environment state with mutations...[/cyan]")
                             try:
-                                # Call API directly with merge_mutations=True to include mutations
-                                state_response = await sessions_state.asyncio(
-                                    client=http_client,
-                                    session_id=session.session_id,
-                                    merge_mutations=True,
-                                    x_api_key=api_key,
-                                )
-                                if state_response and state_response.results:
-                                    for jid, result in state_response.results.items():
-                                        state_data = result.state if hasattr(result, "state") else result
-                                        console.print(f"\n[bold cyan]Job {jid}:[/bold cyan]")
-
-                                        if isinstance(state_data, dict):
-                                            # Check for error in state response
-                                            if "error" in state_data:
-                                                console.print("\n[bold red]❌ State API Error:[/bold red]")
-                                                console.print(f"[red]{state_data['error']}[/red]")
-                                                continue
-
-                                            mutations = state_data.pop("mutations", [])
-                                            console.print("\n[bold]State:[/bold]")
-                                            console.print(json.dumps(state_data, indent=2, default=str))
-                                            if mutations:
-                                                console.print(f"\n[bold]Mutations ({len(mutations)}):[/bold]")
-                                                console.print(json.dumps(mutations, indent=2, default=str))
-                                            else:
-                                                console.print("\n[yellow]No mutations recorded[/yellow]")
+                                # v1 API: env.get_state() returns state dict directly
+                                state_data = await env.get_state(merge_mutations=True)
+                                console.print(f"\n[bold cyan]Environment {env.id}:[/bold cyan]")
+
+                                if isinstance(state_data, dict):
+                                    # Check for error in state response (only if error has a truthy value)
+                                    if state_data.get("error"):
+                                        console.print("\n[bold red]❌ State API Error:[/bold red]")
+                                        console.print(f"[red]{state_data['error']}[/red]")
+                                    else:
+                                        mutations = state_data.pop("mutations", [])
+                                        console.print("\n[bold]State:[/bold]")
+                                        console.print(json.dumps(state_data, indent=2, default=str))
+                                        if mutations:
+                                            console.print(f"\n[bold]Mutations ({len(mutations)}):[/bold]")
+                                            console.print(json.dumps(mutations, indent=2, default=str))
                                         else:
-                                            console.print(json.dumps(state_data, indent=2, default=str))
+                                            console.print("\n[yellow]No mutations recorded[/yellow]")
                                 else:
-                                    console.print("[yellow]No state data available[/yellow]")
+                                    console.print(json.dumps(state_data, indent=2, default=str))
                                 console.print()
                             except Exception as e:
                                 console.print(f"[red]❌ Error getting state: {e}[/red]")
@@ -633,56 +622,60 @@ def review_base(
                 validate_status_transition(current_status, "env_review_requested", "review base reject")
                 new_status = "env_in_progress"
 
-            # Update status
-            await update_simulator_status.asyncio(
-                client=http_client,
-                simulator_id=simulator_id,
-                body=UpdateStatusRequest(status=new_status),
-                x_api_key=api_key,
-            )
-
-            # Add review if rejecting
-            if outcome == "reject":
-                comments = ""
-                while not comments:
-                    comments = typer.prompt("Comments (required for reject)").strip()
-                    if not comments:
-                        console.print("[yellow]Comments are required when rejecting. Please provide feedback.[/yellow]")
-
-                await add_simulator_review.asyncio(
-                    client=http_client,
+            # Create httpx client for API calls
+            async with httpx.AsyncClient(base_url=base_url, timeout=60.0) as api_client:
+                # Update status
+                await update_simulator_status.asyncio(
+                    client=api_client,
                     simulator_id=simulator_id,
-                    body=AddReviewRequest(
-                        review_type=ReviewType.env,
-                        outcome=Outcome.reject,
-                        artifact_id=artifact_id,
-                        comments=comments,
-                    ),
+                    body=UpdateStatusRequest(status=new_status),
                     x_api_key=api_key,
                 )
 
-            console.print(f"[green]✅ Review submitted: {outcome}[/green]")
-            console.print(f"[cyan]Status:[/cyan] {current_status} → {new_status}")
-
-            # If passed, automatically tag artifact as prod-latest
-            if outcome == "pass" and artifact_id:
-                console.print("\n[cyan]Tagging artifact as prod-latest...[/cyan]")
-                try:
-                    # simulator_name and artifact_id are guaranteed to be set at this point
-                    assert simulator_name is not None
-                    await update_tag.asyncio(
-                        client=http_client,
-                        body=UpdateTagRequest(
-                            simulator_name=simulator_name,
+                # Add review if rejecting
+                if outcome == "reject":
+                    comments = ""
+                    while not comments:
+                        comments = typer.prompt("Comments (required for reject)").strip()
+                        if not comments:
+                            console.print(
+                                "[yellow]Comments are required when rejecting. Please provide feedback.[/yellow]"
+                            )
+
+                    await add_simulator_review.asyncio(
+                        client=api_client,
+                        simulator_id=simulator_id,
+                        body=AddReviewRequest(
+                            review_type=ReviewType.env,
+                            outcome=Outcome.reject,
                             artifact_id=artifact_id,
-                            tag_name="prod-latest",
-                            dataset="base",
+                            comments=comments,
                         ),
                         x_api_key=api_key,
                     )
-                    console.print(f"[green]✅ Tagged {artifact_id[:8]}... as prod-latest[/green]")
-                except Exception as e:
-                    console.print(f"[yellow]⚠️  Could not tag as prod-latest: {e}[/yellow]")
+
+                console.print(f"[green]✅ Review submitted: {outcome}[/green]")
+                console.print(f"[cyan]Status:[/cyan] {current_status} → {new_status}")
+
+                # If passed, automatically tag artifact as prod-latest
+                if outcome == "pass" and artifact_id:
+                    console.print("\n[cyan]Tagging artifact as prod-latest...[/cyan]")
+                    try:
+                        # simulator_name and artifact_id are guaranteed to be set at this point
+                        assert simulator_name is not None
+                        await update_tag.asyncio(
+                            client=api_client,
+                            body=UpdateTagRequest(
+                                simulator_name=simulator_name,
+                                artifact_id=artifact_id,
+                                tag_name="prod-latest",
+                                dataset="base",
+                            ),
+                            x_api_key=api_key,
+                        )
+                        console.print(f"[green]✅ Tagged {artifact_id[:8]}... as prod-latest[/green]")
+                    except Exception as e:
+                        console.print(f"[yellow]⚠️  Could not tag as prod-latest: {e}[/yellow]")
 
         except typer.Exit:
             raise
@@ -693,8 +686,6 @@ def review_base(
         finally:
             # Cleanup
             try:
-                if login_result and login_result.context:
-                    await login_result.context.close()
                 if browser:
                     await browser.close()
                 if playwright:
@@ -702,13 +693,13 @@ def review_base(
             except Exception as e:
                 console.print(f"[yellow]⚠️  Browser cleanup error: {e}[/yellow]")
 
-            if session:
+            if env:
                 try:
-                    console.print("[cyan]Shutting down session...[/cyan]")
-                    await session.close()
-                    console.print("[green]✅ Session shut down[/green]")
+                    console.print("[cyan]Shutting down environment...[/cyan]")
+                    await env.close()
+                    console.print("[green]✅ Environment shut down[/green]")
                 except Exception as e:
-                    console.print(f"[yellow]⚠️  Session cleanup error: {e}[/yellow]")
+                    console.print(f"[yellow]⚠️  Environment cleanup error: {e}[/yellow]")
 
             try:
                 await plato.close()

{plato_sdk_v2-2.8.1 → plato_sdk_v2-2.8.2}/plato/cli/sandbox.py

@@ -407,8 +407,9 @@ def sandbox_snapshot(
 
     Captures VM state and database for later restoration.
 
-    Example:
-        plato sandbox snapshot
+    Examples:
+        plato sandbox snapshot                    # Uses mode from state.json
+        plato sandbox snapshot --mode config      # Override to pass local plato-config.yml and flows to artifact
     """
     with sandbox_context(working_dir, json_output, verbose) as (client, out):
         out.console.print("Creating snapshot...")

plato_sdk_v2-2.8.2/plato/v1/cli/pm.py

@@ -0,0 +1,14 @@
+"""Project Management CLI commands for Plato simulator workflow.
+
+This module re-exports from plato.cli.pm for backwards compatibility.
+"""
+
+# Re-export from main CLI for backwards compatibility
+from plato.cli.pm import (
+    list_app,
+    pm_app,
+    review_app,
+    submit_app,
+)
+
+__all__ = ["pm_app", "list_app", "review_app", "submit_app"]

{plato_sdk_v2-2.8.1 → plato_sdk_v2-2.8.2}/plato/v2/sync/sandbox.py

@@ -622,6 +622,28 @@ class SandboxClient:
             raise ValueError("No job ID found")
         self.console.print(f"job_id: {job_id}")
 
+        # For artifact mode, we need to get simulator_name from session details BEFORE generating public URL
+        # Note: get_session_details returns a dict, not a Pydantic model
+        if not simulator_name:
+            session_details = get_session_details.sync(
+                client=self._http,
+                session_id=session_id,
+                x_api_key=self.api_key,
+            )
+            jobs = (
+                session_details.get("jobs")
+                if isinstance(session_details, dict)
+                else getattr(session_details, "jobs", None)
+            )
+            if jobs:
+                for j in jobs:
+                    service = j.get("service") if isinstance(j, dict) else getattr(j, "service", None)
+                    if service:
+                        simulator_name = service
+                        break
+            if not simulator_name:
+                raise ValueError(f"No simulator name found in session details for job ID {job_id}")
+
         # Get public URL with router target formatting (logic inlined)
         public_url = None
         try:
@@ -635,7 +657,7 @@ class SandboxClient:
                     url = result.url if hasattr(result, "url") else str(result)
                     if not url:
                         raise ValueError(f"No public URL found in result dict for job ID {job_id}")
-                    if "_plato_router_target=" not in url:
+                    if "_plato_router_target=" not in url and simulator_name:
                         target_param = f"_plato_router_target={simulator_name}.web.plato.so"
                         if "?" in url:
                             url = f"{url}&{target_param}"
@@ -667,24 +689,6 @@ class SandboxClient:
         heartbeat_pid = None
         heartbeat_pid = _start_heartbeat_process(session_id, self.api_key)
 
-        # Parse out the simulator_name from service field in jobs in session details.
-        session_details = get_session_details.sync(
-            client=self._http,
-            session_id=session_id,
-            x_api_key=self.api_key,
-        )
-        if hasattr(session_details, "jobs"):
-            # session_details["jobs"] if dict, or session_details.jobs if object
-            jobs = (
-                session_details["jobs"] if isinstance(session_details, dict) else getattr(session_details, "jobs", None)
-            )
-            if jobs:
-                for j in jobs:
-                    service = j.get("service") if isinstance(j, dict) else getattr(j, "service", None)
-                    if service:
-                        simulator_name = service
-                        break
-
         # Convert absolute paths to relative for state storage
         def _to_relative(abs_path: str | None) -> str | None:
             if not abs_path or not self.working_dir:
@@ -759,26 +763,39 @@ class SandboxClient:
         checkpoint_request = CreateCheckpointRequest()
 
         if mode == "config":
-            # read plato-config.yml
+            # read plato-config.yml - need parsed for extracting values
             plato_config_path = self.working_dir / "plato-config.yml"
-            with open(plato_config_path, "rb") as f:
-                plato_config = yaml.safe_load(f)
-            checkpoint_request.plato_config = plato_config
+            plato_config_raw = plato_config_path.read_text()
+            plato_config = yaml.safe_load(plato_config_raw)
 
-            # convert plato-config to pydantic model
+            # New format - extract just the dataset portion
             plato_config_model = PlatoConfig.model_validate(plato_config)
-            dataset_compute = plato_config_model.datasets[dataset].compute
+            dataset_config = plato_config_model.datasets[dataset]
+            # Convert dataset config back to dict for YAML serialization
+            dataset_dict = dataset_config.model_dump(exclude_none=True, by_alias=True)
+            checkpoint_request.plato_config = yaml.dump(dataset_dict, default_flow_style=False)
+
+            dataset_compute = dataset_config.compute
             if not dataset_compute:
                 raise ValueError(f"Compute configuration is required for dataset '{dataset}'")
             checkpoint_request.internal_app_port = dataset_compute.app_port
             checkpoint_request.messaging_port = dataset_compute.plato_messaging_port
             # we dont set target
 
-            # read flows.yml
-            flows_path = self.working_dir / "flows.yml"
-            with open(flows_path, "rb") as f:
-                flows = yaml.safe_load(f)
-            checkpoint_request.flows = flows
+            # Read flows from the path specified in plato-config metadata
+            # API expects YAML string, not parsed dict
+            # Only set flows if file exists AND has content, otherwise leave as None to inherit from parent
+            dataset_metadata = dataset_config.metadata
+            flows_file_path = dataset_metadata.flows_path if dataset_metadata else None
+            if flows_file_path:
+                # flows_path is relative to working_dir
+                flows_path = self.working_dir / flows_file_path
+                if flows_path.exists():
+                    flows_content = flows_path.read_text().strip()
+                    if flows_content:
+                        checkpoint_request.flows = flows_content
+                else:
+                    self.console.print(f"[yellow]Warning: flows file not found at {flows_path}[/yellow]")
 
         return sessions_snapshot.sync(
             client=self._http,

plato_sdk_v2-2.8.1/VERSION

@@ -1 +0,0 @@
-2.8.1