refactor: Pipelines subclasses Capsules, move AppPanel back to capsule.py

- Capsules now uses configurable _route for API paths
- Pipelines extends Capsules with _route="pipelines" and method aliases
- Moved AppPanel classes from components.py back to capsule.py
- Added run_pipeline as alias for run_capsule in Computations

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: zvikagart

examples/run_pipeline.py

@@ -38,7 +38,7 @@
     ],
 )
 
-computation = client.computations.run_capsule(run_params)
+computation = client.computations.run_pipeline(run_params)
 
 # Wait for pipeline to finish.
 

src/codeocean/capsule.py

@@ -5,13 +5,7 @@
 from typing import Optional, Iterator
 from requests_toolbelt.sessions import BaseUrlSession
 
-from codeocean.components import (
-    Ownership,
-    SortOrder,
-    SearchFilter,
-    Permissions,
-    AppPanel,
-)
+from codeocean.components import Ownership, SortOrder, SearchFilter, Permissions
 from codeocean.computation import Computation
 from codeocean.data_asset import DataAssetAttachParams, DataAssetAttachResults
 from codeocean.enum import StrEnum
@@ -32,6 +26,29 @@ class CapsuleSortBy(StrEnum):
     Name = "name"
 
 
+class AppPanelDataAssetKind(StrEnum):
+    """The kind of data asset displayed in an app panel.
+
+    - 'Internal' → Data stored inside Code Ocean.
+    - 'External' → Data stored external to Code Ocean.
+    - 'Combined' → Data containing multiple external data assets.
+
+    In pipelines, a data asset can only be replaced with one of the same kind.
+    """
+
+    Internal = "internal"
+    External = "external"
+    Combined = "combined"
+
+
+class AppPanelParameterType(StrEnum):
+    """The type of parameter displayed in an app panel."""
+
+    Text = "text"
+    List = "list"
+    File = "file"
+
+
 @dataclass_json
 @dataclass(frozen=True)
 class OriginalCapsuleInfo:
@@ -255,38 +272,232 @@ class CapsuleSearchResults:
     )
 
 
+@dataclass_json
+@dataclass(frozen=True)
+class AppPanelCategories:
+    """Categories for a capsule's App Panel parameters."""
+
+    id: str = dataclass_field(
+        metadata={"description": "Unique identifier for the category."},
+    )
+    name: str = dataclass_field(
+        metadata={"description": "Human-readable name of the category."},
+    )
+    description: Optional[str] = dataclass_field(
+        default=None,
+        metadata={"description": "Optional detailed description of the category."},
+    )
+    help_text: Optional[str] = dataclass_field(
+        default=None,
+        metadata={"description": "Optional help text providing guidance or additional information about the category."},
+    )
+
+
+@dataclass_json
+@dataclass(frozen=True)
+class AppPanelParameters:
+    """Parameters for a capsule's App Panel."""
+
+    name: str = dataclass_field(
+        metadata={"description": "Parameter label/display name."}
+    )
+    type: AppPanelParameterType = dataclass_field(
+        metadata={"description": "Type of the parameter (text, list, file)."}
+    )
+    category: Optional[str] = dataclass_field(
+        default=None,
+        metadata={"description": "ID of category the parameter belongs to."}
+    )
+    param_name: Optional[str] = dataclass_field(
+        default=None,
+        metadata={"description": "The parameter name/argument key"}
+    )
+    description: Optional[str] = dataclass_field(
+        default=None,
+        metadata={"description": "Description of the parameter."}
+    )
+    help_text: Optional[str] = dataclass_field(
+        default=None,
+        metadata={"description": "Help text for the parameter."}
+    )
+    value_type: Optional[str] = dataclass_field(
+        default=None,
+        metadata={"description": "Value type of the parameter."}
+    )
+    default_value: Optional[str] = dataclass_field(
+        default=None,
+        metadata={"description": "Default value of the parameter."}
+    )
+    required: Optional[bool] = dataclass_field(
+        default=None,
+        metadata={"description": "Indicates if the parameter is required."}
+    )
+    hidden: Optional[bool] = dataclass_field(
+        default=None,
+        metadata={"description": "Indicates if the parameter is hidden."}
+    )
+    minimum: Optional[float] = dataclass_field(
+        default=None,
+        metadata={"description": "Minimum value for the parameter."}
+    )
+    maximum: Optional[float] = dataclass_field(
+        default=None,
+        metadata={"description": "Maximum value for the parameter."}
+    )
+    pattern: Optional[str] = dataclass_field(
+        default=None,
+        metadata={"description": "Regular expression pattern for the parameter."}
+    )
+    value_options: Optional[list[str]] = dataclass_field(
+        default=None,
+        metadata={"description": "Allowed values for the parameter."}
+    )
+
+
+@dataclass_json
+@dataclass(frozen=True)
+class AppPanelGeneral:
+    """General information about a capsule's App Panel."""
+
+    title: Optional[str] = dataclass_field(
+        default=None,
+        metadata={"description": "Title of the App Panel."}
+    )
+    instructions: Optional[str] = dataclass_field(
+        default=None,
+        metadata={"description": "Instructions for using the App Panel."}
+    )
+    help_text: Optional[str] = dataclass_field(
+        default=None,
+        metadata={"description": "Help text for the App Panel."}
+    )
+
+
+@dataclass_json
+@dataclass(frozen=True)
+class AppPanelDataAsset:
+    """Data asset parameter for the App Panel."""
+
+    id: str = dataclass_field(
+        metadata={"description": "Unique identifier for the data asset."}
+    )
+    mount: str = dataclass_field(
+        metadata={"description": "Mount path of the data asset within the capsule. "
+                  "Use this mount path to replace the currently attached data asset with your own"}
+    )
+    name: str = dataclass_field(
+        metadata={"description": "Display name of the data asset."}
+    )
+    kind: AppPanelDataAssetKind = dataclass_field(
+        metadata={"description": "Kind of the data asset (internal, external, combined)."}
+    )
+    accessible: bool = dataclass_field(
+        metadata={"description": "Indicates if the data asset is accessible to the user."}
+    )
+    description: Optional[str] = dataclass_field(
+        default=None,
+        metadata={"description": "Optional description of the data asset parameter."}
+    )
+    help_text: Optional[str] = dataclass_field(
+        default=None,
+        metadata={"description": "Optional help text for the data asset parameter."}
+    )
+
+
+@dataclass_json
+@dataclass(frozen=True)
+class AppPanelResult:
+    """Selected result files to display once the computation is complete."""
+
+    file_name: str = dataclass_field(
+        metadata={"description": "Name of the result file."}
+    )
+
+
+@dataclass_json
+@dataclass(frozen=True)
+class AppPanelProcess:
+    """Pipeline process name and its corresponding app panel (for pipelines of capsules only)"""
+
+    name: str = dataclass_field(
+        metadata={"description": "Name of the pipeline process."}
+    )
+    categories: Optional[AppPanelCategories] = dataclass_field(
+        default=None,
+        metadata={"description": "Categories for the pipeline process's app panel parameters."}
+    )
+    parameters: Optional[AppPanelParameters] = dataclass_field(
+        default=None,
+        metadata={"description": "Parameters for the pipeline process's app panel."}
+    )
+
+
+@dataclass_json
+@dataclass(frozen=True)
+class AppPanel:
+    """App Panel configuration for a capsule or pipeline, including general info, data assets,
+    categories, parameters, and results.
+    """
+
+    general: Optional[AppPanelGeneral] = dataclass_field(
+        default=None,
+        metadata={"description": "General information about the App Panel."}
+    )
+    data_assets: Optional[list[AppPanelDataAsset]] = dataclass_field(
+        default=None,
+        metadata={"description": "List of data assets used in the App Panel."}
+    )
+    categories: Optional[list[AppPanelCategories]] = dataclass_field(
+        default=None,
+        metadata={"description": "Categories for organizing App Panel parameters."}
+    )
+    parameters: Optional[list[AppPanelParameters]] = dataclass_field(
+        default=None,
+        metadata={"description": "Parameters for the App Panel."}
+    )
+    results: Optional[list[AppPanelResult]] = dataclass_field(
+        default=None,
+        metadata={"description": "Result files to display after computation."}
+    )
+    processes: Optional[list[AppPanelProcess]] = dataclass_field(
+        default=None,
+        metadata={"description": "Pipeline processes and their App Panels."}
+    )
+
+
 @dataclass
 class Capsules:
     """Client for interacting with Code Ocean capsule APIs."""
 
     client: BaseUrlSession
+    _route: str = "capsules"
 
     def get_capsule(self, capsule_id: str) -> Capsule:
         """Retrieve metadata for a specific capsule by its ID."""
-        res = self.client.get(f"capsules/{capsule_id}")
+        res = self.client.get(f"{self._route}/{capsule_id}")
 
         return Capsule.from_dict(res.json())
 
     def delete_capsule(self, capsule_id: str):
         """Delete a capsule permanently."""
-        self.client.delete(f"capsules/{capsule_id}")
+        self.client.delete(f"{self._route}/{capsule_id}")
 
     def get_capsule_app_panel(self, capsule_id: str, version: Optional[int] = None) -> AppPanel:
         """Retrieve app panel information for a specific capsule by its ID."""
-        res = self.client.get(f"capsules/{capsule_id}/app_panel", params={"version": version} if version else None)
+        res = self.client.get(f"{self._route}/{capsule_id}/app_panel", params={"version": version} if version else None)
 
         return AppPanel.from_dict(res.json())
 
     def list_computations(self, capsule_id: str) -> list[Computation]:
         """Get all computations associated with a specific capsule."""
-        res = self.client.get(f"capsules/{capsule_id}/computations")
+        res = self.client.get(f"{self._route}/{capsule_id}/computations")
 
         return [Computation.from_dict(c) for c in res.json()]
 
     def update_permissions(self, capsule_id: str, permissions: Permissions):
         """Update permissions for a capsule."""
         self.client.post(
-            f"capsules/{capsule_id}/permissions",
+            f"{self._route}/{capsule_id}/permissions",
             json=permissions.to_dict(),
         )
 
@@ -297,7 +508,7 @@ def attach_data_assets(
     ) -> list[DataAssetAttachResults]:
         """Attach one or more data assets to a capsule with optional mount paths."""
         res = self.client.post(
-            f"capsules/{capsule_id}/data_assets",
+            f"{self._route}/{capsule_id}/data_assets",
             json=[j.to_dict() for j in attach_params],
         )
 
@@ -306,21 +517,21 @@ def attach_data_assets(
     def detach_data_assets(self, capsule_id: str, data_assets: list[str]):
         """Detach one or more data assets from a capsule by their IDs."""
         self.client.delete(
-            f"capsules/{capsule_id}/data_assets/",
+            f"{self._route}/{capsule_id}/data_assets/",
             json=data_assets,
         )
 
     def archive_capsule(self, capsule_id: str, archive: bool):
         """Archive or unarchive a capsule to control its visibility and accessibility."""
         self.client.patch(
-            f"capsules/{capsule_id}/archive",
+            f"{self._route}/{capsule_id}/archive",
             params={"archive": archive},
         )
 
     def search_capsules(self, search_params: CapsuleSearchParams) -> CapsuleSearchResults:
         """Search for capsules with filtering, sorting, and pagination
         options."""
-        res = self.client.post("capsules/search", json=search_params.to_dict())
+        res = self.client.post(f"{self._route}/search", json=search_params.to_dict())
 
         return CapsuleSearchResults.from_dict(res.json())