codeocean-mcp-server 0.1.0__py3-none-any.whl

codeocean_mcp_server/file_utils.py

@@ -0,0 +1,21 @@
+"""File utilities for downloading and reading files."""
+
+import requests
+
+# Constants
+MAX_FILE_CONTENT_LENGTH = 50_000  # Maximum length of content to read
+DOWNLOAD_TIMEOUT = 30
+
+
+def download_and_read_file(url: str) -> str:
+    """Download file from URL and return first MAX_FILE_CONTENT_LENGTH characters."""
+    try:
+        with requests.get(url, timeout=DOWNLOAD_TIMEOUT, stream=True) as response:
+            response.raise_for_status()
+            # Read the first 'bytes_to_read' bytes of the response
+            data = response.raw.read(MAX_FILE_CONTENT_LENGTH)
+            # Decode the data into a string using the response's encoding
+            return data.decode(response.encoding or "utf-8", errors="ignore")
+
+    except requests.exceptions.RequestException as e:
+        return f"Download error: {e}"

codeocean_mcp_server/models.py

@@ -0,0 +1,89 @@
+from dataclasses import fields, is_dataclass
+from typing import Any, List, Type, get_args, get_origin, get_type_hints
+
+from pydantic import BaseModel, Field, create_model
+
+
+def dataclass_to_pydantic(
+    data_class: Type[Any], cache: dict[Type[Any], Type[BaseModel]] = None
+) -> Type[BaseModel]:
+    """Convert a dataclass to Pydantic model.
+
+    Recursively convert a frozen @dataclass (and nested dataclasses)
+    into validating Pydantic BaseModel subclasses — resolving all
+    forward/string annotations via get_type_hints().
+    """
+    if cache is None:
+        cache = {}
+    if data_class in cache:
+        return cache[data_class]
+    assert is_dataclass(data_class), (
+        f"{data_class.__name__} is not a dataclass"
+    )
+
+    # 1) Resolve all annotations to real types (no strings)
+    module_ns = vars(
+        __import__(data_class.__module__, fromlist=["*"])
+    )
+    type_hints = get_type_hints(
+        data_class, globalns=module_ns, localns=module_ns
+    )
+
+    definitions: dict[str, tuple[type, Any]] = {}
+    for field in fields(data_class):
+        # Use the evaluated hint if available, else the raw annotation
+        typ = type_hints.get(field.name, field.type)
+        default = field.default
+        field_type = typ
+        origin = get_origin(typ)
+        args = get_args(typ)
+
+        # 2) Nested dataclass → build or fetch nested model
+        if is_dataclass(typ):
+            nested_model = dataclass_to_pydantic(typ, cache)
+            field_type = nested_model
+
+        # 3) List[...] of dataclasses → List[NestedModel]
+        elif origin in (list, List) and args and is_dataclass(args[0]):
+            nested_model = dataclass_to_pydantic(args[0], cache)
+            field_type = List[nested_model]
+
+        # 4) Handle field with description from metadata
+        field_info = default
+        if field.metadata and "description" in field.metadata:
+            # Create a Pydantic Field with description
+            field_info = Field(
+                default=default, description=field.metadata["description"]
+            )
+
+        definitions[field.name] = (field_type, field_info)
+
+    # 5) Dynamically create the Pydantic model
+    model = create_model(
+        f"{data_class.__name__}Model",
+        __base__=BaseModel,
+        __doc__=data_class.__doc__,
+        **definitions
+    )
+
+    # 6) Override the schema generation to include description from docstring
+    if data_class.__doc__:
+        original_json_schema = model.model_json_schema
+
+        def custom_json_schema(*args, **kwargs):
+            schema = original_json_schema(*args, **kwargs)
+            schema["description"] = data_class.__doc__.strip()
+            return schema
+
+        model.model_json_schema = custom_json_schema
+
+    model.model_rebuild()
+
+    def to_dict_method(self):
+        return self.model_dump()
+
+    # 7) Add a method to convert the model instance to a dictionary
+    model.to_dict = to_dict_method
+
+    cache[data_class] = model
+    return model

codeocean_mcp_server/server.py

@@ -0,0 +1,36 @@
+import os
+
+from codeocean import CodeOcean
+from mcp.server.fastmcp import FastMCP
+
+from codeocean_mcp_server.tools import capsules, computations, data_assets
+
+
+def main():
+    """Run the MCP server."""
+    domain = os.getenv("CODEOCEAN_DOMAIN")
+    token = os.getenv("CODEOCEAN_TOKEN")
+    if not domain or not token:
+        raise ValueError(
+            "Environment variables CODEOCEAN_DOMAIN and "
+            "CODEOCEAN_TOKEN must be set."
+        )
+    client = CodeOcean(domain=domain, token=token)
+
+    mcp = FastMCP(
+        name="Code Ocean",
+        description=(
+            f"MCP server for Code Ocean: search & run capsules, "
+            f"pipelines, and assets using Code Ocean domain {domain}."
+        ),
+    )
+
+    capsules.add_tools(mcp, client)
+    data_assets.add_tools(mcp, client)
+    computations.add_tools(mcp, client)
+
+    mcp.run()
+
+
+if __name__ == "__main__":
+    main()

codeocean_mcp_server/tools/capsules.py

@@ -0,0 +1,75 @@
+from codeocean import CodeOcean
+from codeocean.capsule import (
+    Capsule,
+    CapsuleSearchParams,
+    CapsuleSearchResults,
+    Computation,
+    DataAssetAttachParams,
+    DataAssetAttachResults,
+)
+from mcp.server.fastmcp import FastMCP
+
+from codeocean_mcp_server.models import dataclass_to_pydantic
+
+CapsuleModel = dataclass_to_pydantic(Capsule)
+CapsuleSearchParamsModel = dataclass_to_pydantic(CapsuleSearchParams)
+CapsuleSearchResultsModel = dataclass_to_pydantic(CapsuleSearchResults)
+ComputationModel = dataclass_to_pydantic(Computation)
+DataAssetAttachParamsModel = dataclass_to_pydantic(DataAssetAttachParams)
+DataAssetAttachResultsModel = dataclass_to_pydantic(DataAssetAttachResults)
+
+
+def add_tools(mcp: FastMCP, client: CodeOcean):
+    """Add capsule tools to the MCP server."""
+
+    @mcp.tool(
+        description=(
+            str(client.capsules.search_capsules.__doc__)
+            + "Use only for capsule searches. "
+            "Provide only the minimal required parameters (e.g. limit=10); "
+            "do not include optional params "
+            "like sort_by or sort_order unless requested."
+        )
+    )
+    def search_capsules(
+        search_params: CapsuleSearchParamsModel,
+    ) -> CapsuleSearchResultsModel:
+        """Search for capsules matching specified criteria."""
+        params = CapsuleSearchParams(**search_params.model_dump(exclude_none=True))
+        return dataclass_to_pydantic(client.capsules.search_capsules(params))
+
+    @mcp.tool(
+        description=(
+            str(client.capsules.attach_data_assets.__doc__)
+            + "Accepts a list of parameter objects (e.g. [{'id': '...'}]), "
+            "not just a list of IDs."
+        )
+    )
+    def attach_data_assets(
+        capsule_id: str,
+        data_asset_ids: list[DataAssetAttachParamsModel],
+    ) -> list[DataAssetAttachResultsModel]:
+        """Attach data assets to a capsule."""
+        return [
+            dataclass_to_pydantic(result)
+            for result in client.capsules.attach_data_assets(capsule_id, data_asset_ids)
+        ]
+
+    @mcp.tool(
+        description=(
+            str(client.capsules.get_capsule.__doc__)
+            + "Use only to fetch metadata for a known capsule ID. "
+            "Do not use for searching."
+        )
+    )
+    def get_capsule(capsule_id: str) -> CapsuleModel:
+        """Retrieve a capsule by its ID."""
+        return dataclass_to_pydantic(client.capsules.get_capsule(capsule_id))
+
+    @mcp.tool(description=client.capsules.list_computations.__doc__)
+    def list_computations(capsule_id: str) -> list[ComputationModel]:
+        """List all computations for a capsule."""
+        return [
+            dataclass_to_pydantic(computation)
+            for computation in client.capsules.list_computations(capsule_id)
+        ]

codeocean_mcp_server/tools/computations.py

@@ -0,0 +1,77 @@
+from codeocean import CodeOcean
+from codeocean.computation import (
+    Computation,
+    DownloadFileURL,
+    Folder,
+    RunParams,
+)
+from mcp.server.fastmcp import FastMCP
+
+from codeocean_mcp_server.file_utils import download_and_read_file
+from codeocean_mcp_server.models import dataclass_to_pydantic
+
+ComputationModel = dataclass_to_pydantic(Computation)
+DownloadFileURLModel = dataclass_to_pydantic(DownloadFileURL)
+FolderModel = dataclass_to_pydantic(Folder)
+RunParamsModel = dataclass_to_pydantic(RunParams)
+
+
+def add_tools(mcp: FastMCP, client: CodeOcean):
+    """Add capsule tools to the MCP server."""
+
+    @mcp.tool(description=client.computations.get_computation.__doc__)
+    def get_computation(computation_id: str) -> list[ComputationModel]:
+        """Retrieve a specific computation by its unique identifier."""
+        return [
+            dataclass_to_pydantic(computation)
+            for computation in client.computations.get_computation(computation_id)
+        ]
+
+    @mcp.tool(
+        description=(
+            str(client.computations.run_capsule.__doc__)
+            + "Typical workflow: 1) run_capsule() to start execution "
+            "2) wait_until_completed() to monitor progress "
+            "3) list_computation_results() and get_result_file_download_url() "
+            "to retrieve outputs."
+        )
+    )
+    def run_capsule(run_params: RunParamsModel) -> ComputationModel:
+        """Execute a capsule or a pipeline in Code Ocean and don't wait."""
+        return dataclass_to_pydantic(client.computations.run_capsule(run_params))
+
+    @mcp.tool(description=client.computations.wait_until_completed.__doc__)
+    def wait_until_completed(computation_id: str) -> ComputationModel:
+        """Wait until a computation completes and return its details."""
+        # first get the computation based on the computation_id:
+        computation = client.computations.get_computation(computation_id)
+        return dataclass_to_pydantic(client.computations.wait_until_completed(computation))
+
+    @mcp.tool(
+        description=(
+            str(client.computations.list_computation_results.__doc__)
+            + " computation_id is required as string"
+        )
+    )
+    def list_computation_results(computation_id: str) -> FolderModel:
+        """List the output files generated by a completed computation."""
+        return dataclass_to_pydantic(
+            client.computations.list_computation_results(computation_id)
+        )
+
+    @mcp.tool(description=(client.computations.get_result_file_download_url.__doc__))
+    def get_result_file_download_url(computation_id: str, file_path: str) -> DownloadFileURLModel:
+        """Get download URL for a specific result file from computation."""
+        return dataclass_to_pydantic(
+            client.computations.get_result_file_download_url(computation_id, file_path),
+        )
+
+    @mcp.tool(
+        description=(
+            "Use when you want to read the content of a file from a computation"
+        )
+    )
+    def download_and_read_a_file_from_computation(computation_id: str, file_path: str) -> str:
+        """Download a file using the provided URL and return its content."""
+        file_url = client.computations.get_result_file_download_url(computation_id, file_path)
+        return download_and_read_file(file_url.url)

codeocean_mcp_server/tools/data_assets.py

@@ -0,0 +1,123 @@
+import os
+
+from codeocean import CodeOcean
+from codeocean.data_asset import (
+    DataAsset,
+    DataAssetAttachParams,
+    DataAssetParams,
+    DataAssetSearchParams,
+    DataAssetSearchResults,
+    DataAssetUpdateParams,
+    DownloadFileURL,
+    Folder,
+)
+from mcp.server.fastmcp import FastMCP
+
+from codeocean_mcp_server.file_utils import download_and_read_file
+from codeocean_mcp_server.models import dataclass_to_pydantic
+
+DataAssetAttachParamsModel = dataclass_to_pydantic(DataAssetAttachParams)
+DataAssetModel = dataclass_to_pydantic(DataAsset)
+DataAssetParamsModel = dataclass_to_pydantic(DataAssetParams)
+DataAssetSearchParamsModel = dataclass_to_pydantic(DataAssetSearchParams)
+DataAssetSearchResultsModel = dataclass_to_pydantic(DataAssetSearchResults)
+DataAssetUpdateParamsModel = dataclass_to_pydantic(DataAssetUpdateParams)
+DownloadFileURLModel = dataclass_to_pydantic(DownloadFileURL)
+FolderModel = dataclass_to_pydantic(Folder)
+
+
+def add_tools(mcp: FastMCP, client: CodeOcean):
+    """Add data asset tools to the MCP server."""
+
+    @mcp.tool(
+        description=(
+            str(client.data_assets.search_data_assets.__doc__)
+            + "Search for data assets (external or internal). You may filter by "
+            "fields such as `origin`, tags, or other criteria supported by the "
+            "SDK."
+        )
+    )
+    def search_data_assets(search_params: DataAssetSearchParamsModel) -> DataAssetSearchResultsModel:
+        """Retrieve data assets matching search criteria for datasets."""
+        params = DataAssetSearchParams(**search_params.model_dump(exclude_none=True))
+        return dataclass_to_pydantic(client.data_assets.search_data_assets(params))
+
+    @mcp.tool(
+        description=(
+            str(client.data_assets.get_data_asset_file_download_url.__doc__)
+            + "Call only when the data asset is already created and in a ready "
+            "state. If the asset may not yet be ready, first use "
+            "`wait_until_ready` to poll until readiness, then retrieve the "
+            "download URL."
+        )
+    )
+    def get_data_asset_file_download_url(
+        data_asset_id: str,
+        file_path: str | None = None,
+    ) -> DownloadFileURLModel:
+        """Get a download URL for a specific file in a data asset."""
+        return dataclass_to_pydantic(
+            client.data_assets.get_data_asset_file_download_url(data_asset_id, file_path),
+        )
+
+    @mcp.tool(
+        description=(
+            "Use when you want to read the content of a file from a data asset"
+        )
+    )
+    def download_and_read_a_file_from_data_asset(data_asset_id: str, file_path: str) -> str:
+        """Download a file using the provided URL and return its content."""
+        file_url = client.data_assets.get_data_asset_file_download_url(data_asset_id, file_path)
+        return download_and_read_file(file_url.url)
+
+    @mcp.tool(description=client.data_assets.list_data_asset_files.__doc__)
+    def list_data_asset_files(data_asset_id: str) -> FolderModel:
+        """List files in a data asset."""
+        return dataclass_to_pydantic(
+            client.data_assets.list_data_asset_files(data_asset_id),
+        )
+
+    @mcp.tool(description=client.data_assets.update_metadata.__doc__)
+    def update_metadata(
+        data_asset_id: str,
+        update_params: DataAssetUpdateParamsModel,
+    ) -> DataAssetModel:
+        """Update metadata for a specific data asset."""
+        update_params = DataAssetUpdateParams(**update_params)
+        return dataclass_to_pydantic(
+            client.data_assets.update_metadata(data_asset_id, update_params)
+        )
+
+    @mcp.tool(
+        description=(
+            str(client.data_assets.wait_until_ready.__doc__)
+            + "Poll until the specified data asset becomes ready before "
+            "performing further operations (e.g., downloading files). You can "
+            "set `polling_interval` and optional `timeout`."
+        )
+    )
+    def wait_until_ready(
+        data_asset: DataAssetModel,
+        polling_interval: float = 5,
+        timeout: float | None = None,
+    ) -> DataAssetModel:
+        """Wait until a data asset is ready."""
+        result = client.data_assets.wait_until_ready(
+            DataAsset(**data_asset.model_dump(exclude_none=True)),
+            polling_interval=polling_interval,
+            timeout=timeout,
+        )
+
+        return dataclass_to_pydantic(result)
+
+    @mcp.tool(
+        description=(
+            str(client.data_assets.create_data_asset.__doc__)
+            + f"You can link to the created data assets with the 'data_asset_id' "
+            f"with the pattern: {os.getenv('CODEOCEAN_DOMAIN', 'unknown')} with /data-assets/<data_asset_id>."
+        )
+    )
+    def create_data_asset(data_asset_params: DataAssetParamsModel) -> DataAssetModel:
+        """Create a new data asset."""
+        params = DataAssetParams(**data_asset_params.model_dump(exclude_none=True))
+        return dataclass_to_pydantic(client.data_assets.create_data_asset(params))

codeocean_mcp_server-0.1.0.dist-info/METADATA

@@ -0,0 +1,201 @@
+Metadata-Version: 2.4
+Name: codeocean-mcp-server
+Version: 0.1.0
+Summary: Code Ocean MCP Server
+Project-URL: Homepage, https://github.com/codeocean/codeocean-mcp-server
+Project-URL: Issues, https://github.com/codeocean/codeocean-mcp-server/issues
+Project-URL: Changelog, https://github.com/codeocean/codeocean-mcp-server/blob/main/CHANGELOG.md
+Author-email: Code Ocean <dev@codeocean.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Requires-Dist: codeocean>=0.7.0
+Requires-Dist: fastmcp>=2.9.2
+Description-Content-Type: text/markdown
+
+# Code Ocean MCP Server
+
+Model Context Protocol (MCP) server for Code Ocean.
+
+This MCP server provides tools to search and run capsules and pipelines, and manage data assets.
+
+## Table of Contents
+
+- [Prerequisites](#prerequisites)
+- [Installation](#installation)
+    - [Visual Studio Code](#visual-studio-code)
+    - [Claude Desktop](#claude-desktop)
+    - [Cline](#cline)
+    - [Roo Code](#roo-code)
+    - [Cursor](#cursor)
+    - [Windsurf](#windsurf)
+
+## Prerequisites
+
+1. Install `uv` from [Astral](https://docs.astral.sh/uv/getting-started/installation/) or the [GitHub README](https://github.com/astral-sh/uv#installation)
+2. Install Python 3.10 or newer using `uv python install 3.10` (or a more recent version)
+3. Generate a Code Ocean access token. Follow instructions in the [Code Ocean user guide](https://docs.codeocean.com/user-guide/code-ocean-api/authentication).
+
+## Installation
+
+## [Visual Studio Code](https://code.visualstudio.com/docs/copilot/chat/mcp-servers)
+
+Here's an example VS Code MCP server configuration:
+```json
+{
+    ...
+    "mcp": {
+        "inputs": [
+            {
+            "type": "promptString",
+            "id": "codeocean-token",
+            "description": "Code Ocean API Key", 
+            "password": true
+            }
+        ],
+        "servers": {
+            "codeocean": {
+                "type": "stdio",
+                "command": "uvx",
+                "args": ["codeocean-mcp-server"],
+                "env": {
+                    "CODEOCEAN_DOMAIN": "https://codeocean.acme.com",
+                    "CODEOCEAN_TOKEN": "${input:codeocean-token}"
+                }
+            }
+        },
+    }
+}
+```
+
+---
+
+## [Claude Desktop](https://modelcontextprotocol.io/quickstart/user)
+
+1.	Open the `claude_desktop_config.json` file:
+ - macOS: `~/Library/Application Support/Claude/claude_desktop_config.json`
+ - Windows: `%APPDATA%\Claude\claude_desktop_config.json`
+2.	Under the top-level "mcpServers" object, add a "codeocean" entry. For a stdio transport (child-process) it looks like this:
+
+```json
+{
+  "mcpServers": {
+    "codeocean": {
+      "command": "uvx",
+      "args": ["codeocean-mcp-server"],
+      "env": {
+        "CODEOCEAN_DOMAIN": "https://codeocean.acme.com",
+        "CODEOCEAN_TOKEN": "<YOUR_API_KEY>"
+      }
+    }
+  }
+}
+```
+
+---
+
+## [Cline](https://docs.cline.bot/mcp/configuring-mcp-servers)
+
+Cline stores all of its MCP settings in a JSON file called cline_mcp_settings.json. You can edit this either through the GUI (“Configure MCP Servers” in the MCP Servers pane) or by hand:
+1.	Open Cline and click the MCP Servers icon in the sidebar.
+2.	In the “Installed” tab, click Configure MCP Servers → this opens your cline_mcp_settings.json.
+3.	Add a "codeocean" server under the "mcpServers" key. For stdio transport:
+```json
+{
+  "mcpServers": {
+    "codeocean": {
+      "command": "uvx",
+      "args": ["codeocean-mcp-server"],
+      "env": {
+        "CODEOCEAN_DOMAIN": "https://codeocean.acme.com",
+        "CODEOCEAN_TOKEN": "<YOUR_API_KEY>"
+      },
+      "alwaysAllow": [],       // optional: list of tools to auto-approve
+      "disabled": false        // ensure it’s enabled
+    }
+  }
+}
+```
+4.	Save the file. Cline will automatically detect and launch the new server, making your Code Ocean tools available in chat .
+
+--- 
+
+## [Roo Code](https://docs.roocode.com/features/mcp/using-mcp-in-roo/)
+
+Roo Code’s MCP support is configured globally across all workspaces via a JSON settings file or through its dedicated MCP Settings UI 
+
+### Via the MCP Settings UI:
+1.	Click the MCP icon in Roo Code’s sidebar.  
+2.	Select Edit MCP Settings (opens cline_mcp_settings.json).  
+3.	Under "mcpServers", add:
+
+```json
+{
+  "mcpServers": {
+    "codeocean": {
+      "command": "uvx",
+      "args": ["codeocean-mcp-server"],
+      "env": {
+        "CODEOCEAN_DOMAIN": "https://codeocean.acme.com",
+        "CODEOCEAN_TOKEN": "<YOUR_API_KEY>"
+      }
+    }
+  }
+}
+```
+4.	Save and restart Roo Code; your Code Ocean tools will appear automatically.
+
+### Optional: Manually editing cline_mcp_settings.json
+1.	Locate cline_mcp_settings.json (in your home directory or workspace).  
+2.	Insert the same "codeocean" block under "mcpServers" as above.
+3.	Save and restart.
+
+---
+
+## [Cursor](https://docs.cursor.com/context/model-context-protocol)
+
+Cursor stores MCP servers in a JSON file at either ~/.cursor/mcp.json (global) or {project}/.cursor/mcp.json (project-specific)  .
+1.	Open .cursor/mcp.json (or create it if missing).  
+2.	Add under "mcpServers":
+```json
+{
+  "mcpServers": {
+    "codeocean": {
+      "command": "uvx",
+      "args": ["codeocean-mcp-server"],
+      "env": {
+        "CODEOCEAN_DOMAIN": "https://codeocean.acme.com",
+        "CODEOCEAN_TOKEN": "<YOUR_API_KEY>"
+      }
+    }
+  }
+}
+```
+3.	Save the file. Cursor will automatically detect and launch the new server on next start.  
+
+---
+
+## [Windsurf](https://docs.windsurf.com/windsurf/cascade/mcp)
+
+Windsurf (Cascade) uses mcp_config.json under ~/.codeium/windsurf/ (or via the Cascade → MCP Servers UI)  .
+1.	Open your Windsurf Settings and navigate to Cascade → MCP Servers, then click View Raw Config to open mcp_config.json.  
+2.	Insert the following under "mcpServers":
+```json
+{
+  "mcpServers": {
+    "codeocean": {
+      "command": "uvx",
+      "args": ["codeocean-mcp-server"],
+      "env": {
+        "CODEOCEAN_DOMAIN": "https://codeocean.acme.com",
+        "CODEOCEAN_TOKEN": "<YOUR_API_KEY>"
+      }
+    }
+  }
+}
+```
+
+3.	Save and restart Windsurf (or hit “Refresh” in the MCP panel).

codeocean_mcp_server-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+codeocean_mcp_server/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+codeocean_mcp_server/file_utils.py,sha256=iXhgkJ5CkZrm-7_x3HVc_ucHF9ZJENHfbR7TZ_mmcPI,817
+codeocean_mcp_server/models.py,sha256=n-wGlUwz94dlJmjvtOjYE4JfgHtlOoQHRVwME3FnnX8,2996
+codeocean_mcp_server/server.py,sha256=JErl9kZgXvfn4OGm0kDkdq9h2r6_mQkMlPmTj099Z3Q,900
+codeocean_mcp_server/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+codeocean_mcp_server/tools/capsules.py,sha256=Llf234em469WoBAg4krJMzNQqqi0at7TWGlHOEOtEm4,2792
+codeocean_mcp_server/tools/computations.py,sha256=LGu_l9KCVIzJJKJJbdYMQDTAHVj17UawI8bVzi1AXr4,3318
+codeocean_mcp_server/tools/data_assets.py,sha256=o4Ze1P1jygeN_glPQ4dP_o2Q_DElZHbYEUxTjlkJhto,5016
+codeocean_mcp_server-0.1.0.dist-info/METADATA,sha256=8TerkbAP1iXu4B6yT0UySfPQmz7rumIoToll6Y2nv8E,6281
+codeocean_mcp_server-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+codeocean_mcp_server-0.1.0.dist-info/entry_points.txt,sha256=MeJye6ajSv37_8SGIGRUuYx8v1Wyod-XtbcRS7UDXpo,74
+codeocean_mcp_server-0.1.0.dist-info/licenses/LICENSE,sha256=JUAoUpOdro6pzi4jINXDMdsz420i1h9oZ5u_I_TCBKI,1067
+codeocean_mcp_server-0.1.0.dist-info/RECORD,,

codeocean_mcp_server-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

codeocean_mcp_server-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+codeocean-mcp-server = codeocean_mcp_server.server:main

codeocean_mcp_server-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Code Ocean
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.