plotly-cloud 0.3.0__tar.gz → 0.4.0__tar.gz

{plotly_cloud-0.3.0 → plotly_cloud-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plotly-cloud
-Version: 0.3.0
+Version: 0.4.0
 Summary: Python extension for Plotly Cloud with CLI and Dash dev tools integration
 Project-URL: Repository, https://github.com/plotly/plotly-cloud-extension
 License-File: LICENSE

{plotly_cloud-0.3.0 → plotly_cloud-0.4.0}/plotly_cloud/__init__.py

@@ -1,3 +1,3 @@
 """Plotly Cloud Extension package."""
 
-__version__ = "0.3.0"
+__version__ = "0.4.0"

{plotly_cloud-0.3.0 → plotly_cloud-0.4.0}/plotly_cloud/_api_types.py

@@ -56,3 +56,30 @@ class App(TypedDict):
 class UserTeamMembership(TypedDict):
     team: Team
     role: str
+
+
+class Build(TypedDict):
+    id: NotRequired[str]
+    revisionId: NotRequired[str]
+    imageRef: NotRequired[str]
+    sourceKey: NotRequired[str]
+    pythonVersion: NotRequired[str]
+
+
+class Revision(TypedDict):
+    id: str
+    workloadId: NotRequired[str]
+    revisionNumber: NotRequired[int]
+    status: NotRequired[str]
+    replicaSet: NotRequired[str]
+    createdBy: NotRequired[str]
+    createdByEmail: NotRequired[str]
+    createdByFirstName: NotRequired[str]
+    createdByLastName: NotRequired[str]
+    build: NotRequired[Build]
+
+
+class DashlogsNotFound(TypedDict):
+    error: str
+    reason: str
+    retention_days: int

{plotly_cloud-0.3.0 → plotly_cloud-0.4.0}/plotly_cloud/_commands.py

@@ -34,6 +34,7 @@ from plotly_cloud._parser import ParsedArguments
 
 from .exceptions import (
     ApplicationError,
+    AuthenticationError,
     CredentialError,
     DashAppError,
     ModuleImportError,
@@ -787,6 +788,95 @@ class PublishCommand(BaseCommand):
             console.print(f"Your app is available at: {format_app_url(app_url)}")
 
 
+class ListCommand(BaseCommand):
+    """List all apps for the authenticated user."""
+
+    name = "list"
+    group = "app"
+    short_description = "📋 List all your published apps"
+    description = "Display all applications published to Plotly Cloud."
+    arguments: List[CommandArgument] = [
+        {
+            "name": "--team",
+            "help": "Filter apps by team name or slug",
+        },
+        {
+            "name": "--team-id",
+            "help": "Filter apps by team ID",
+        },
+    ]
+
+    @classmethod
+    async def execute(cls, args: ParsedArguments) -> None:
+        """Execute list command."""
+        client_id = cloud_config.get_oauth_client_id()
+        oauth_client = OAuthClient(client_id, token=getattr(args, "api_key", None))
+
+        if not await oauth_client.is_authenticated():
+            raise ApplicationError("Not authenticated. Please run 'plotly login' first.")
+
+        auth_token = await oauth_client.get_access_token()
+        if not auth_token:
+            raise ApplicationError("Unable to retrieve access token. Please try logging in again.")
+
+        async with DeploymentClient(oauth_client) as deploy_client:
+            # Resolve team name/slug to team_id if needed
+            team_id = getattr(args, "team_id", None)
+            team_name_or_slug = getattr(args, "team", None)
+
+            if team_name_or_slug and not team_id:
+                teams = await deploy_client.list_teams()
+                for team in teams:
+                    if (
+                        team.get("name", "").lower() == team_name_or_slug.lower()
+                        or team.get("team_slug", "").lower() == team_name_or_slug.lower()
+                        or team.get("id", "").lower() == team_name_or_slug.lower()
+                    ):
+                        team_id = team.get("id")
+                        break
+                if not team_id:
+                    raise ApplicationError(
+                        f"Team '{team_name_or_slug}' not found. Use 'plotly user teams' to list available teams."
+                    )
+
+            apps = await deploy_client.list_apps(team_id)
+
+        if not apps:
+            console.print(Panel("No apps found.", title="📋 Apps", border_style="yellow"))
+            return
+
+        table = Table(show_header=True, header_style="bold blue", expand=True)
+        table.add_column("Name", style="cyan", no_wrap=True, ratio=3)
+        table.add_column("Status", style="white", no_wrap=True, ratio=1)
+        table.add_column("App ID", style="dim", no_wrap=True, ratio=1)
+        table.add_column("Published", style="magenta", no_wrap=True, ratio=1)
+
+        for app in apps:
+            status = app.get("status", "—")
+            status_info = REVISION_STATUS_MAP.get(status, {"label": status, "emoji": "?", "color": "white"})
+            status_display = (
+                f"{status_info['emoji']}  [{status_info['color']}]{status_info['label']}[/{status_info['color']}]"
+            )
+
+            last_published = app.get("last_published", "—")
+            if last_published and last_published != "—":
+                last_published = last_published[:10]
+
+            app_id = app.get("id", "—")
+            app_id_short = app_id[:8] if app_id != "—" else "—"
+
+            table.add_row(
+                app.get("name", "—"),
+                status_display,
+                app_id_short,
+                last_published,
+            )
+
+        console.print()
+        console.print(Panel.fit(table, title="📋 Your Apps", border_style="bold blue"))
+        console.print()
+
+
 class StatusCommand(BaseCommand):
     """Get the status of an app published to Plotly Cloud."""
 
@@ -932,6 +1022,94 @@ class TeamsCommand(BaseCommand):
         console.print()
 
 
+class LogsCommand(BaseCommand):
+    """Get build or runtime logs for a published app."""
+
+    name = "logs"
+    group = "app"
+    short_description = "📋 Get logs for a published app"
+    description = "Retrieve build or runtime logs for your published application."
+    arguments: List[CommandArgument] = [
+        {
+            "name": "--project-path",
+            "default": ".",
+            "help": "Path to project directory",
+        },
+        {
+            "name": "--config",
+            "default": "plotly-cloud.toml",
+            "help": "Path to configuration file",
+        },
+        {
+            "name": "--type",
+            "default": "build",
+            "choices": ["build", "runtime"],
+            "help": "Type of logs to retrieve (default: build)",
+        },
+        {
+            "name": "--revision",
+            "help": "Revision ID (default: latest revision)",
+        },
+    ]
+
+    @classmethod
+    async def execute(cls, args: ParsedArguments) -> None:
+        """Execute logs command."""
+        project_path = os.path.abspath(args.project_path)
+        config_path = get_config_path(project_path, args.config)
+        config = load_deployment_config(config_path)
+
+        app_id = config.get("app_id")
+        if not app_id:
+            raise ApplicationError("No app_id found in configuration. Publish your app first using 'plotly publish'.")
+
+        client_id = cloud_config.get_oauth_client_id()
+        oauth_client = OAuthClient(client_id, token=getattr(args, "api_key", None))
+
+        if not await oauth_client.is_authenticated():
+            raise AuthenticationError("Not authenticated. Please run 'plotly login' first.")
+
+        auth_token = await oauth_client.get_access_token()
+        if not auth_token:
+            raise AuthenticationError("Unable to retrieve access token. Please try logging in again.")
+
+        log_type = getattr(args, "type", "build")
+        revision_id = getattr(args, "revision", None)
+
+        async with DeploymentClient(oauth_client) as deploy_client:
+            with Progress(
+                SpinnerColumn(),
+                TextColumn("[progress.description]{task.description}"),
+                console=console,
+            ) as progress:
+                # Resolve revision ID if not provided
+                if not revision_id:
+                    task = progress.add_task("Fetching latest revision...", total=None)
+                    revisions = await deploy_client.get_app_revisions(app_id)
+                    if not revisions:
+                        raise ApplicationError("No revisions found for this app.")
+                    revision_id = revisions[0]["id"]
+                    progress.update(task, description=f"✓ Using revision {revision_id[:8]}...")
+
+                # Fetch logs
+                task = progress.add_task(f"Fetching {log_type} logs...", total=None)
+                log_text, _ = await deploy_client.get_logs(app_id, revision_id, log_type)
+                progress.remove_task(task)
+
+            if not log_text.strip():
+                console.print(f"No {log_type} logs available.")
+                return
+
+            console.print(
+                Panel(
+                    log_text,
+                    title=f"📋 {log_type.title()} Logs",
+                    border_style="blue",
+                    expand=True,
+                )
+            )
+
+
 class WhoamiCommand(BaseCommand):
     """Show current user information."""
 

{plotly_cloud-0.3.0 → plotly_cloud-0.4.0}/plotly_cloud/_deploy.py

@@ -11,7 +11,7 @@ import httpx
 import tomli
 import tomli_w
 
-from plotly_cloud._api_types import App, AppRequest, Team
+from plotly_cloud._api_types import App, AppRequest, DashlogsNotFound, Revision, Team, UserTeamMembership
 from plotly_cloud._cloud_env import cloud_config
 from plotly_cloud._definitions import AppDeploymentConfig
 from plotly_cloud._oauth import OAuthClient
@@ -112,9 +112,7 @@ def should_exclude_path(path: str, exclude_patterns: set[str]) -> bool:
     return False
 
 
-async def create_deployment_zip(
-    project_path: str, output_path: str, skip_size_check: bool = False
-) -> int:
+async def create_deployment_zip(project_path: str, output_path: str, skip_size_check: bool = False) -> int:
     """
     Create a zip file for deployment, excluding files based on .gitignore.
 
@@ -512,8 +510,8 @@ class DeploymentClient:
                 response = await self._client.get(url)
 
                 if response.status_code == 200:
-                    teams: list[Team] = response.json()
-                    return teams
+                    memberships: list[UserTeamMembership] = response.json()
+                    return [m["team"] for m in memberships]
 
                 token_refreshed = await self._refresh_token_if_needed(response)
                 if token_refreshed:
@@ -524,3 +522,166 @@ class DeploymentClient:
             raise _handle_error_response(response, "list teams")
         except httpx.RequestError as e:
             raise NetworkError("Failed to list teams", str(e)) from e
+
+    async def list_apps(self, team_id: Optional[str] = None) -> list[App]:
+        """List all apps for the authenticated user.
+
+        Args:
+            team_id: Optional team ID to filter apps by
+
+        Returns:
+            List of App objects
+
+        Raises:
+            DeploymentClientError: If client is not initialized
+            APIError: If API call fails
+            NetworkError: If network request fails
+        """
+        if not self._client:
+            raise DeploymentClientError("Client not initialized. Use within async context manager.")
+
+        url = f"https://{self.api_base_url}/api/apps"
+        params = {}
+        if team_id:
+            params["teamId"] = team_id
+
+        try:
+            retry_count = 0
+            response = None
+            while retry_count <= 1:
+                response = await self._client.get(url, params=params)
+
+                if response.status_code == 200:
+                    apps: list[App] = response.json()
+                    return apps
+
+                token_refreshed = await self._refresh_token_if_needed(response)
+                if token_refreshed:
+                    retry_count += 1
+                else:
+                    break
+
+            raise _handle_error_response(response, "list apps")
+        except httpx.RequestError as e:
+            raise NetworkError("Failed to list apps", str(e)) from e
+
+    async def get_app_revisions(self, app_id: str) -> list[Revision]:
+        """Get revisions for an application.
+
+        Args:
+            app_id: Application ID
+
+        Returns:
+            List of Revision objects
+
+        Raises:
+            DeploymentClientError: If client is not initialized
+            APIError: If API call fails
+            NetworkError: If network request fails
+        """
+        if not self._client:
+            raise DeploymentClientError("Client not initialized. Use within async context manager.")
+
+        url = f"https://{self.api_base_url}/api/app/{app_id}/revisions"
+
+        try:
+            retry_count = 0
+            response = None
+            while retry_count <= 1:
+                response = await self._client.get(url)
+
+                if response.status_code == 200:
+                    data = response.json()
+                    revisions: list[Revision] = data.get("revisions", data) if isinstance(data, dict) else data
+                    return revisions
+
+                token_refreshed = await self._refresh_token_if_needed(response)
+                if token_refreshed:
+                    retry_count += 1
+                else:
+                    break
+
+            raise _handle_error_response(response, "get app revisions")
+        except httpx.RequestError as e:
+            raise NetworkError("Failed to get app revisions", str(e)) from e
+
+    async def get_logs(
+        self,
+        app_id: str,
+        revision_id: str,
+        log_type: str = "build",
+        continue_token: Optional[str] = None,
+    ) -> tuple[str, Optional[str]]:
+        """Get build or runtime logs for an app revision.
+
+        Uses the dashlogs streaming endpoints which return log lines
+        followed by a JSON meta line with continuation token.
+
+        Args:
+            app_id: Application ID
+            revision_id: Revision ID
+            log_type: "build" or "runtime"
+            continue_token: Continuation token from a previous response
+
+        Returns:
+            Tuple of (log_text, next_continue_token).
+            next_continue_token is None if there are no more logs.
+
+        Raises:
+            DeploymentClientError: If client is not initialized
+            APIError: If API call fails (including 202 when logs not available)
+            NetworkError: If network request fails
+        """
+        if not self._client:
+            raise DeploymentClientError("Client not initialized. Use within async context manager.")
+
+        url = f"https://{self.api_base_url}/api/app/{app_id}/dashlogs/{revision_id}/{log_type}"
+        params = {}
+        if continue_token:
+            params["continue"] = continue_token
+
+        try:
+            retry_count = 0
+            response = None
+            while retry_count <= 1:
+                response = await self._client.get(url, params=params)
+
+                if response.status_code == 200:
+                    body = response.text
+                    # The last line is a JSON meta line with continuation info
+                    lines = body.rstrip("\n").split("\n")
+                    next_token = None
+                    log_lines = lines
+                    if lines:
+                        try:
+                            meta = json.loads(lines[-1])
+                            next_token = meta.get("next_token")
+                            log_lines = lines[:-1]
+                        except (json.JSONDecodeError, ValueError):
+                            pass
+                    return "\n".join(log_lines), next_token
+
+                if response.status_code == 202:
+                    not_found: DashlogsNotFound = response.json()
+                    reason = not_found.get("reason", "unknown")
+                    if reason == "expired":
+                        raise APIError(
+                            "Logs have expired",
+                            status_code=202,
+                            details=f"Logs are deleted after {not_found.get('retention_days', '?')} days",
+                        )
+                    raise APIError(
+                        "Logs not available yet",
+                        status_code=202,
+                        details="Build may still be in progress",
+                    )
+
+                token_refreshed = await self._refresh_token_if_needed(response)
+                if token_refreshed:
+                    retry_count += 1
+                else:
+                    break
+
+            raise _handle_error_response(response, f"get {log_type} logs")
+        except httpx.RequestError as e:
+            raise NetworkError(f"Failed to get {log_type} logs", str(e)) from e

{plotly_cloud-0.3.0 → plotly_cloud-0.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "plotly-cloud"
-version = "0.3.0"
+version = "0.4.0"
 description = "Python extension for Plotly Cloud with CLI and Dash dev tools integration"
 readme = "README.md"
 requires-python = ">=3.9"