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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plotly-cloud
-Version: 0.2.1
+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.2.1 → plotly_cloud-0.4.0}/plotly_cloud/__init__.py

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

{plotly_cloud-0.2.1 → 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.2.1 → plotly_cloud-0.4.0}/plotly_cloud/_changes.py

@@ -7,8 +7,7 @@ from concurrent.futures import ThreadPoolExecutor
 _builtins_modules = list(sys.builtin_module_names) + ["frozen", "builtin"]
 
 
-if hasattr(sys, "stdlib_module_names"):
-    _builtins_modules += list(sys.stdlib_module_names)  # type: ignore
+_builtins_modules += list(getattr(sys, "stdlib_module_names", []))
 
 
 def collect_module_files(*extras):

{plotly_cloud-0.2.1 → 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,
@@ -461,7 +462,7 @@ class PublishCommand(BaseCommand):
         },
         {
             "name": "--poll-status",
-            "type": lambda x: x.lower() in ("true", "1", "yes", "on"),  # type: ignore
+            "type": lambda x: x.lower() in ("true", "1", "yes", "on"),
             "default": True,
             "help": "Poll publishing status until completion (default: True)",
         },
@@ -477,6 +478,11 @@ class PublishCommand(BaseCommand):
             "default": 180,
             "help": "Polling timeout in seconds",
         },
+        {
+            "name": "--skip-size-check",
+            "action": "store_true",
+            "help": "Skip the standard 200MB project size validation (note: a hard 700MB maximum still applies)",
+        },
     ]
 
     @classmethod
@@ -584,7 +590,7 @@ class PublishCommand(BaseCommand):
             auth_task = progress.add_task("🔐 Checking authentication...", total=None)
 
             client_id = cloud_config.get_oauth_client_id()
-            oauth_client = OAuthClient(client_id)
+            oauth_client = OAuthClient(client_id, token=getattr(args, "api_key", None))
 
             # Check if authenticated, if not, perform login
             if not await oauth_client.is_authenticated():
@@ -666,7 +672,8 @@ class PublishCommand(BaseCommand):
                 try:
                     # Create deployment zip
                     package_task = progress.add_task("Creating deployment package...", total=None)
-                    zip_size = await create_deployment_zip(project_path, zip_path)
+                    skip_size_check = getattr(args, "skip_size_check", False)
+                    zip_size = await create_deployment_zip(project_path, zip_path, skip_size_check)
                     progress.update(
                         package_task, description=f"✓ Created deployment package: {zip_size / (1024 * 1024):.1f}MB"
                     )
@@ -781,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."""
 
@@ -816,15 +912,12 @@ class StatusCommand(BaseCommand):
         if not app_id:
             raise ApplicationError("No app_id found in configuration. Publish your app first using 'plotly publish'.")
 
-        # Get OAuth client for authentication
         client_id = cloud_config.get_oauth_client_id()
-        oauth_client = OAuthClient(client_id)
+        oauth_client = OAuthClient(client_id, token=getattr(args, "api_key", None))
 
-        # Check if authenticated
         if not await oauth_client.is_authenticated():
             raise ApplicationError("Not authenticated. Please run 'plotly login' first.")
 
-        # Get access token
         auth_token = await oauth_client.get_access_token()
         if not auth_token:
             raise ApplicationError("Unable to retrieve access token. Please try logging in again.")
@@ -885,15 +978,12 @@ class TeamsCommand(BaseCommand):
     @classmethod
     async def execute(cls, args: ParsedArguments) -> None:
         """Execute teams command."""
-        # Get OAuth client for authentication
         client_id = cloud_config.get_oauth_client_id()
-        oauth_client = OAuthClient(client_id)
+        oauth_client = OAuthClient(client_id, token=getattr(args, "api_key", None))
 
-        # Check if authenticated
         if not await oauth_client.is_authenticated():
             raise ApplicationError("Not authenticated. Please run 'plotly login' first.")
 
-        # Get access token
         auth_token = await oauth_client.get_access_token()
         if not auth_token:
             raise ApplicationError("Unable to retrieve access token. Please try logging in again.")
@@ -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."""
 
@@ -944,25 +1122,26 @@ class WhoamiCommand(BaseCommand):
     @classmethod
     async def execute(cls, args: ParsedArguments) -> None:
         """Execute the whoami command."""
+        token = getattr(args, "api_key", None)
+        if token:
+            console.print("✓ Authenticated via bearer token")
+            return
+
         client_id = cloud_config.get_oauth_client_id()
         oauth_client = OAuthClient(client_id)
 
-        # Check if authenticated
         if not await oauth_client.is_authenticated():
             console.print("✗ Not logged in")
             return
 
-        # Load credentials to get user info
         credentials = await oauth_client.load_credentials()
         if not credentials:
             console.print("✗ No credentials found")
             return
 
-        # Try to refresh token to validate it
         try:
             await oauth_client.refresh_access_token()
 
-            # Extract user information from credentials
             user_info = credentials.get("user", {})
             email = user_info.get("email") or credentials.get("email")
 
@@ -972,6 +1151,5 @@ class WhoamiCommand(BaseCommand):
                 console.print("✓ Logged in (no email information available)")
 
         except (TokenError, CredentialError):
-            # Token is invalid and cannot be refreshed, clear credentials
             await oauth_client.logout()
             console.print("✗ Invalid token - credentials cleared")

{plotly_cloud-0.2.1 → 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
@@ -30,8 +30,9 @@ from .exceptions import (
     PlotlyCloudError,
 )
 
-# Maximum allowed zip file size (200MB)
+# Maximum allowed zip file size (200MB default, 700MB absolute max)
 MAX_ZIP_SIZE = 200 * 1024 * 1024
+ABSOLUTE_MAX_ZIP_SIZE = 700 * 1024 * 1024
 
 
 def parse_gitignore(project_path: str) -> set[str]:
@@ -111,19 +112,21 @@ def should_exclude_path(path: str, exclude_patterns: set[str]) -> bool:
     return False
 
 
-async def create_deployment_zip(project_path: str, output_path: str) -> 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.
 
     Args:
         project_path: Path to the project directory
         output_path: Path where the zip file should be created
+        skip_size_check: If True, skip the maximum size validation
 
     Returns:
         Size of the created zip file in bytes
 
     Raises:
-        ValueError: If zip file exceeds size limit
+        FileSizeError: If zip file exceeds size limit and skip_size_check is False
+        FileSystemError: If the .gitignore file cannot be read
     """
     exclude_patterns = parse_gitignore(project_path)
     total_uncompressed_size = 0
@@ -165,7 +168,18 @@ async def create_deployment_zip(project_path: str, output_path: str) -> int:
     # Check uncompressed size only
     zip_size = os.path.getsize(output_path)
 
-    if total_uncompressed_size > MAX_ZIP_SIZE:
+    # Always enforce absolute maximum (700MB)
+    if total_uncompressed_size > ABSOLUTE_MAX_ZIP_SIZE:
+        os.remove(output_path)  # Clean up the oversized zip
+        raise FileSizeError(
+            f"This directory exceeds {ABSOLUTE_MAX_ZIP_SIZE / (1024 * 1024):.0f}MB and couldn't be published",
+            f"Total size: {total_uncompressed_size / (1024 * 1024):.1f}MB. "
+            f"Maximum allowed: {ABSOLUTE_MAX_ZIP_SIZE / (1024 * 1024):.0f}MB. "
+            "Consider excluding large files in your .gitignore.",
+        )
+
+    # Check default limit (200MB) unless skipped
+    if not skip_size_check and total_uncompressed_size > MAX_ZIP_SIZE:
         os.remove(output_path)  # Clean up the oversized zip
         raise FileSizeError(
             f"This directory exceeds {MAX_ZIP_SIZE / (1024 * 1024):.0f}MB and couldn't be published",
@@ -247,7 +261,8 @@ def _handle_error_response(response: Optional[httpx.Response], operation: str) -
 
     # Handle 403 Forbidden specifically
     if response.status_code == 403:
-        return ForbiddenError(f"Failed to {operation}: Access forbidden")
+        details = response.text.strip()[:200] if response.text else ""
+        return ForbiddenError(f"Failed to {operation}: Access forbidden", details=details)
 
     # Parse error based on content type
     content_type = response.headers.get("content-type", "").lower()
@@ -495,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:
@@ -507,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.2.1 → plotly_cloud-0.4.0}/plotly_cloud/_devtool_hooks.py

@@ -10,7 +10,7 @@ def install_hook():
 
     try:
         # The style only works with the position left defined.
-        dash.hooks.devtool(  # type: ignore
+        dash.hooks.devtool(
             "plotly_cloud_publish_component",
             "PlotlyCloudPublishComponent",
             {"id": "_plotly-cloud-publish"},

{plotly_cloud-0.2.1 → plotly_cloud-0.4.0}/plotly_cloud/_devtool_publish_rpc.py

@@ -226,7 +226,7 @@ class PlotlyCloudPublishRPC:
         device_code = data.get("device_code")
         status_code, response = await self.oauth_client.check_authentication_status(device_code)
         if status_code == 200:
-            await self.oauth_client._save_credentials(dict(response))
+            await self.oauth_client._save_credentials({**response})
             return {"result": {"success": True}}
         else:
             error = response.get("error", "unknown_error")

{plotly_cloud-0.2.1 → plotly_cloud-0.4.0}/plotly_cloud/_oauth.py

@@ -59,8 +59,9 @@ AuthResponse = Union[AuthTokenResponse, AuthErrorResponse]
 class OAuthClient:
     """OAuth client for WorkOS CLI Auth using device authorization flow."""
 
-    def __init__(self, client_id: str):
+    def __init__(self, client_id: str, token: Optional[str] = None):
         self.client_id = client_id
+        self.token = token
         self.credentials_path = self._get_credentials_path()
 
     def _get_credentials_path(self) -> Path:
@@ -278,11 +279,15 @@ class OAuthClient:
 
     async def is_authenticated(self) -> bool:
         """Check if user is authenticated."""
+        if self.token:
+            return True
         credentials = await self.load_credentials()
         return credentials is not None and "access_token" in credentials
 
     async def get_access_token(self) -> Optional[str]:
         """Get current access token."""
+        if self.token:
+            return self.token
         credentials = await self.load_credentials()
         if credentials:
             return credentials.get("access_token")
@@ -294,6 +299,8 @@ class OAuthClient:
         Raises:
             TokenError: If no refresh token available or refresh fails
         """
+        if self.token:
+            raise TokenError("Cannot refresh a static API key")
         credentials = await self.load_credentials()
         if not credentials or "refresh_token" not in credentials:
             raise TokenError("No refresh token available")

{plotly_cloud-0.2.1 → plotly_cloud-0.4.0}/plotly_cloud/_parser.py

@@ -1,5 +1,6 @@
 """Simple argument parser to replace argparse."""
 
+import os
 import sys
 from typing import Any, List
 
@@ -78,9 +79,10 @@ def parse_args(command_arguments: List[CommandArgument], args_index=3) -> Parsed
 
         result[key] = arg_spec.get("default")
 
-    # Add global verbose flag and help flag
+    # Add global flags
     result["verbose"] = False
     result["help"] = False
+    result["api_key"] = os.getenv("PLOTLY_API_KEY", None)
 
     # Check if the first argument is "help" and handle it specially
     if len(args) > 0 and args[0] == "help":
@@ -103,6 +105,14 @@ def parse_args(command_arguments: List[CommandArgument], args_index=3) -> Parsed
             i += 1
             continue
 
+        if arg == "--api-key":
+            if i + 1 < len(args):
+                result["api_key"] = args[i + 1]
+                i += 2
+            else:
+                i += 1
+            continue
+
         # Check if this is an optional argument
         if arg.startswith("-"):
             # Find matching optional argument specification

{plotly_cloud-0.2.1 → plotly_cloud-0.4.0}/plotly_cloud/cli.py

@@ -110,6 +110,10 @@ def print_main_help(show_banner=True) -> None:
 
     # Show global options
     global_options = [
+        {
+            "name": "--api-key",
+            "help": "API key for authentication (overrides OAuth, or set PLOTLY_API_KEY env var)",
+        },
         {
             "name": "--verbose, -v",
             "help": "Enable verbose output with detailed error information",
@@ -196,6 +200,10 @@ def print_command_help(command_class: BaseCommand, group: str, command: str) ->
 
     # Show global options
     global_options = [
+        {
+            "name": "--api-key",
+            "help": "API key for authentication (overrides OAuth, or set PLOTLY_API_KEY env var)",
+        },
         {
             "name": "--verbose, -v",
             "help": "Enable verbose output with detailed error information",

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

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