marvin 3.2.2__tar.gz → 3.2.4__tar.gz

{marvin-3.2.2 → marvin-3.2.4}/.gitignore

@@ -25,3 +25,4 @@ wheels/
 **/*.db
 **/*.sqlite
 sandbox/
+.research_cache/

{marvin-3.2.2 → marvin-3.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: marvin
-Version: 3.2.2
+Version: 3.2.4
 Summary: a simple and powerful tool to get things done with AI
 License:                                  Apache License
                                    Version 2.0, January 2004
@@ -209,7 +209,7 @@ Requires-Dist: aiosqlite>=0.20.0
 Requires-Dist: alembic>=1.12.0
 Requires-Dist: jinja2>=3.1.4
 Requires-Dist: partial-json-parser>=0.2.1.1.post5
-Requires-Dist: pydantic-ai>=0.7.2
+Requires-Dist: pydantic-ai>=1.9.0
 Requires-Dist: pydantic-settings>=2.6.1
 Requires-Dist: pydantic[email]>=2.10.6
 Requires-Dist: rich>=13.9.4
@@ -238,10 +238,10 @@ Marvin provides an intuitive API for defining workflows and delegating work to L
 
 ## Installation
 
-Install `marvin`:
+Marvin is available on [PyPI](https://pypi.org/project/marvin/):
 
 ```bash
-uv pip install marvin
+uv add marvin
 ```
 
 Configure your LLM provider (Marvin uses OpenAI by default but natively supports [all Pydantic AI models](https://ai.pydantic.dev/models/)):

{marvin-3.2.2 → marvin-3.2.4}/README.md

@@ -13,10 +13,10 @@ Marvin provides an intuitive API for defining workflows and delegating work to L
 
 ## Installation
 
-Install `marvin`:
+Marvin is available on [PyPI](https://pypi.org/project/marvin/):
 
 ```bash
-uv pip install marvin
+uv add marvin
 ```
 
 Configure your LLM provider (Marvin uses OpenAI by default but natively supports [all Pydantic AI models](https://ai.pydantic.dev/models/)):

{marvin-3.2.2 → marvin-3.2.4}/docs/api-reference/marvin-database.mdx

@@ -120,15 +120,16 @@ Custom type for Usage objects that stores them as JSON in the database.
 
 ### `create_db_and_tables`
 ```python
-def create_db_and_tables(force: bool = False)
+def create_db_and_tables(force: bool = False, dispose_engine: bool = False)
 ```
-Create all database tables synchronously.
-
-This is a synchronous alternative to create_db_and_tables() that can be used
-in contexts where asyncio.run() cannot be called.
+Create all database tables.
 
 Args:
     force: If True, drops all existing tables before creating new ones.
+    dispose_engine: If True, dispose the engine after creating tables.
+        This is useful when called from asyncio.run() to ensure the
+        aiosqlite worker thread is cleaned up and doesn't prevent
+        Python from exiting.
 
 ### `ensure_db_tables_exist`
 ```python

{marvin-3.2.2 → marvin-3.2.4}/docs/concepts/agents.mdx

@@ -109,21 +109,6 @@ agent = marvin.Agent(
 )
 ```
 
-### Delegates
-
-Agents can be configured with a list of other agents that they can delegate work to. This is particularly useful when working with teams of agents:
-
-```python
-import marvin
-
-researcher = marvin.Agent(name="Researcher")
-writer = marvin.Agent(name="Writer")
-editor = marvin.Agent(
-    name="Editor",
-    delegates=[researcher, writer]
-)
-```
-
 ## Assigning agents to tasks
 
 Agents must be assigned to tasks in order to work on them. You can assign agents by passing them to the `agents` parameter when creating a task:

{marvin-3.2.2 → marvin-3.2.4}/docs/installation.mdx

@@ -18,8 +18,6 @@ The easiest way to install Marvin is a package manager like `pip` or [`uv`](http
 ```bash uv
 # add marvin to your project
 uv add marvin
-# add marvin to your virtual environment
-uv pip install marvin
 # add marvin to your script
 uv add --script some_script.py marvin
 # run a python process with marvin installed ephemerally

{marvin-3.2.2 → marvin-3.2.4}/docs/patterns/memory.mdx

@@ -140,7 +140,7 @@ pip install "marvin[chroma]"
 ```
 
 ```bash uv
-uv pip install "marvin[chroma]"
+uv add "marvin[chroma]"
 ```
 </CodeGroup>
 
@@ -170,7 +170,7 @@ pip install "marvin[lance]"
 ```
 
 ```bash uv
-uv pip install "marvin[lance]"
+uv add "marvin[lance]"
 ```
 
 </CodeGroup>
@@ -198,7 +198,7 @@ pip install "marvin[postgres]"
 ```
 
 ```bash uv
-uv pip install "marvin[postgres]"
+uv add "marvin[postgres]"
 ```
 
 </CodeGroup>
@@ -229,7 +229,7 @@ pip install "marvin" "qdrant-client[fastembed]"
 ```
 
 ```bash uv
-uv pip install "marvin" "qdrant-client[fastembed]"
+uv add marvin "qdrant-client[fastembed]"
 ```
 
 </CodeGroup>
@@ -259,6 +259,6 @@ pip install "marvin[memory]"  # Includes chroma, lance, postgres, qdrant
 ```
 
 ```bash uv
-uv pip install "marvin[memory]"  # Includes chroma, lance, postgres and qdrant
+uv add "marvin[memory]"  # Includes chroma, lance, postgres and qdrant
 ```
 </CodeGroup>

marvin-3.2.4/examples/provider_specific/aimlapi/run_agent.py

@@ -0,0 +1,49 @@
+"""
+» AIML_API_KEY=your-api-key \
+uv run examples/provider_specific/aimlapi/run_agent.py
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from pydantic_ai.models.openai import OpenAIModel
+from pydantic_ai.providers.openai import OpenAIProvider
+
+import marvin
+
+AIML_API_URL = "https://api.aimlapi.com/v1"
+
+
+def get_provider() -> OpenAIProvider:
+    api_key = os.getenv("AIML_API_KEY")
+    if not api_key:
+        raise RuntimeError(
+            "Set AIML_API_KEY environment variable to your AI/ML API key."
+        )
+    return OpenAIProvider(api_key=api_key, base_url=AIML_API_URL)
+
+
+def write_file(path: str, content: str) -> None:
+    """Write content to a file."""
+    Path(path).write_text(content)
+
+
+def main() -> None:
+    writer = marvin.Agent(
+        model=OpenAIModel("gpt-4o", provider=get_provider()),
+        name="AI/ML Writer",
+        instructions="Write concise, engaging content for developers",
+        tools=[write_file],
+    )
+
+    result = marvin.run(
+        "how to use pydantic? write haiku to docs.md",
+        agents=[writer],
+    )
+    print(result)
+
+
+if __name__ == "__main__":
+    main()

marvin-3.2.4/examples/provider_specific/aimlapi/structured_output.py

@@ -0,0 +1,54 @@
+"""
+» AIML_API_KEY=your-api-key \
+uv run examples/provider_specific/aimlapi/structured_output.py
+"""
+
+from __future__ import annotations
+
+import os
+
+from pydantic_ai.models.openai import OpenAIModel
+from pydantic_ai.providers.openai import OpenAIProvider
+from typing_extensions import TypedDict
+
+import marvin
+
+AIML_API_URL = "https://api.aimlapi.com/v1"
+
+
+class LearningResource(TypedDict):
+    title: str
+    url: str
+    summary: str
+
+
+def get_provider() -> OpenAIProvider:
+    api_key = os.getenv("AIML_API_KEY")
+    if not api_key:
+        raise RuntimeError(
+            "Set AIML_API_KEY environment variable to your AI/ML API key."
+        )
+    return OpenAIProvider(api_key=api_key, base_url=AIML_API_URL)
+
+
+def main() -> None:
+    researcher = marvin.Agent(
+        model=OpenAIModel("gpt-4o", provider=get_provider()),
+        name="Resource Researcher",
+        instructions=(
+            "Return structured JSON describing useful developer resources for the AI/ML API."
+        ),
+    )
+
+    resources = marvin.run(
+        "share three quickstart resources for building with the AI/ML API",
+        result_type=list[LearningResource],
+        agents=[researcher],
+    )
+
+    for resource in resources:
+        print(f"- {resource['title']}\n  {resource['url']}\n  {resource['summary']}\n")
+
+
+if __name__ == "__main__":
+    main()

marvin-3.2.4/examples/provider_specific/aimlapi/tools_agent.py

@@ -0,0 +1,58 @@
+"""
+» AIML_API_KEY=your-api-key \
+uv run examples/provider_specific/aimlapi/tools_agent.py
+"""
+
+from __future__ import annotations
+
+import os
+from datetime import date, timedelta
+
+from pydantic_ai.models.openai import OpenAIModel
+from pydantic_ai.providers.openai import OpenAIProvider
+
+import marvin
+
+AIML_API_URL = "https://api.aimlapi.com/v1"
+
+
+def get_provider() -> OpenAIProvider:
+    api_key = os.getenv("AIML_API_KEY")
+    if not api_key:
+        raise RuntimeError(
+            "Set AIML_API_KEY environment variable to your AI/ML API key."
+        )
+    return OpenAIProvider(api_key=api_key, base_url=AIML_API_URL)
+
+
+def get_event_date(offset_days: int = 0) -> str:
+    """Return an ISO formatted date offset from today."""
+    today = date.today()
+    return (today + timedelta(days=offset_days)).isoformat()
+
+
+def mock_weather_lookup(city: str) -> str:
+    """Pretend to look up weather for a city."""
+    return f"The forecast in {city} calls for mild temperatures and light winds."
+
+
+def main() -> None:
+    planner = marvin.Agent(
+        model=OpenAIModel("gpt-4o", provider=get_provider()),
+        name="AI/ML Event Planner",
+        instructions=(
+            "Plan concise community events for AI/ML API enthusiasts."
+            " Use the available tools for dates and weather when helpful."
+        ),
+        tools=[get_event_date, mock_weather_lookup],
+    )
+
+    plan = marvin.run(
+        "Design a Saturday workshop introducing the AI/ML API in Berlin",
+        agents=[planner],
+    )
+    print(plan)
+
+
+if __name__ == "__main__":
+    main()

marvin-3.2.4/examples/slackbot/Dockerfile.slackbot

@@ -0,0 +1,25 @@
+FROM python:3.13-slim
+
+COPY --from=ghcr.io/astral-sh/uv:latest /uv /uvx /bin/
+COPY --from=oven/bun:latest /usr/local/bin/bun /usr/local/bin/bun
+
+WORKDIR /app
+
+COPY . /app
+
+RUN apt-get update && \
+    apt-get install -y git build-essential curl && \
+    curl -fsSL https://deb.nodesource.com/setup_20.x | bash - && \
+    apt-get install -y nodejs && \
+    apt-get clean && \
+    rm -rf /var/lib/apt/lists/*
+
+RUN uv sync --extra slackbot --no-dev
+
+RUN bun install -g @anthropic-ai/claude-code
+
+ENV PATH="/root/.bun/bin:${PATH}"
+
+EXPOSE 4200
+
+CMD ["uv", "run", "--no-sync", "-m", "slackbot"]

{marvin-3.2.2 → marvin-3.2.4}/examples/slackbot/README.md

@@ -18,12 +18,8 @@ The slackbot can be run locally with minimal setup.
 ### Local Development
 
 ```console
-# Create and activate a virtual environment with uv
-uv venv --python 3.12
-source .venv/bin/activate
-
-# Install dependencies
-uv pip install -e ".[slackbot]" -U
+# Install dependencies (from the repo root)
+uv sync --extra slackbot
 ```
 
 ### Configuration

{marvin-3.2.2 → marvin-3.2.4}/examples/slackbot/pyproject.toml

@@ -41,6 +41,7 @@ dependencies = [
   "numpy",
   "raggy[tpuf] @ git+https://github.com/zzstoatzz/raggy.git",
   "pretty-mod",
+  "claude-agent-sdk",
 ]
 
 

marvin-3.2.4/examples/slackbot/src/slackbot/_internal/constants.py

@@ -0,0 +1 @@
+WORKSPACE_TO_CHANNEL_ID: dict[str, str] = {}

{marvin-3.2.2 → marvin-3.2.4}/examples/slackbot/src/slackbot/api.py

@@ -279,12 +279,7 @@ async def handle_message(payload: SlackPayload, db: Database):
                 channel_id=event.channel,
                 thread_ts=thread_ts,
             )
-            # Still return completed so we don't retry
-            return Completed(
-                message="Error during agent execution",
-                name="ERROR_HANDLED",
-                data=dict(error=str(e), user_context=user_context),
-            )
+            raise
         finally:
             try:
                 await mark_thread_completed(db, message_ts)

{marvin-3.2.2 → marvin-3.2.4}/examples/slackbot/src/slackbot/github/models.py

@@ -18,7 +18,7 @@ class GitHubLabel(BaseModel):
 
     name: str = Field(default="")
     color: str = Field(default="")
-    description: str = Field(default="")
+    description: str | None = Field(default="")
 
 
 class GitHubComment(BaseModel):

marvin-3.2.4/examples/slackbot/src/slackbot/research_agent.py

@@ -0,0 +1,127 @@
+"""Research agent for improved information gathering.
+
+Now uses Claude Agent SDK for direct code inspection instead of relying on
+documentation search alone. This prevents hallucination by allowing the agent
+to actually read Prefect source code.
+"""
+
+from pathlib import Path
+
+from claude_agent_sdk import ClaudeAgentOptions, ClaudeSDKClient
+from claude_agent_sdk.types import AssistantMessage, TextBlock
+from prefect import task
+from prefect.cache_policies import INPUTS
+
+
+async def research_topic_with_code_access(question: str, version: str = "3.x") -> str:
+    """
+    Research a Prefect topic using Claude Agent SDK with direct source code access.
+
+    The agent will clone the Prefect repo to .research_cache/prefect if it doesn't exist,
+    or update it if it does. This works consistently in both local and Docker environments.
+
+    Args:
+        question: The research question
+        version: Prefect version ("2.x" or "3.x")
+
+    Returns:
+        Research findings as a formatted string
+    """
+    # Use current working directory for cache
+    # Locally: <wherever you run from>/.research_cache/prefect
+    # Docker: /app/.research_cache/prefect (since WORKDIR is /app)
+    cache_dir = Path.cwd() / ".research_cache"
+    prefect_repo = cache_dir / "prefect"
+
+    version_context = "Prefect 3.x" if version.startswith("3") else "Prefect 2.x"
+    branch = "main" if version.startswith("3") else "2.x"
+
+    system_prompt = f"""You are a specialized research agent for {version_context}.
+Your job is to thoroughly research topics by reading the actual Prefect source code, documentation, and community discussions.
+
+IMPORTANT: Before researching, ensure you have the Prefect source code:
+1. If {prefect_repo} doesn't exist: clone it with `git clone https://github.com/PrefectHQ/prefect.git {prefect_repo}`
+2. If it already exists: update it with `cd {prefect_repo} && git checkout {branch} && git pull`
+3. Then search/read both:
+   - Source code in {prefect_repo}/src/prefect/
+   - Documentation in {prefect_repo}/docs/
+
+DOCUMENTATION:
+- Read docs from {prefect_repo}/docs/v3/ (or {prefect_repo}/docs/ on 2.x branch)
+- Use {prefect_repo}/docs/docs.json to map file paths to published URLs at https://docs.prefect.io/
+- Verify all doc links with `curl -I <url>` before providing them - never hallucinate URLs
+
+If cloning fails (e.g., disk space), fall back to searching the installed package in your current environment.
+
+ADDITIONAL RESEARCH TOOLS:
+- Use `gh` CLI to search GitHub discussions and issues for community-verified solutions
+- Example: `gh search issues --repo PrefectHQ/prefect "custom state event"`
+- This helps find real-world patterns and edge cases that users have discovered
+
+Use your tools to search and read the actual implementation - do not make assumptions.
+Be thorough - verify everything by reading the source.
+
+CRITICAL VERSION-SPECIFIC RULES:
+- **DEFAULT TO {version_context}**: Do NOT suggest deprecated patterns
+- **NEVER** suggest `Deployment.build_from_flow()` for Prefect 3.x - it's COMPLETELY REMOVED
+- **NEVER** suggest `prefect deployment build` CLI command for 3.x - use `prefect deploy` instead
+- The correct deployment pattern in 3.x is: `flow.from_source(...).deploy(...)`
+- Default to Prefect 3.x patterns unless user explicitly states they're using 2.x
+- If user is on 2.x, suggest upgrading to 3.x or using workers instead of deprecated patterns
+
+Remember: You are the research specialist. The main agent relies on you for accurate, comprehensive information.
+Be thorough - use tools repeatedly until you have complete information.
+Do not use any Prefect syntax you have not verified by reading the actual source code."""
+
+    options = ClaudeAgentOptions(
+        allowed_tools=["Read", "Grep", "Glob", "Bash"],
+        cwd=str(Path.cwd()),
+        model="claude-haiku-4-5-20251001",
+        system_prompt=system_prompt,
+    )
+
+    research_output = []
+
+    async with ClaudeSDKClient(options=options) as client:
+        await client.query(question)
+
+        async for message in client.receive_response():
+            if isinstance(message, AssistantMessage):
+                for block in message.content:
+                    if isinstance(block, TextBlock):
+                        research_output.append(block.text)
+
+    return "\n".join(research_output)
+
+
+def research_prefect_topic(question: str, topic: str, version: str = "3.x") -> str:
+    """
+    Thoroughly research a Prefect topic using Claude Agent SDK with source code access.
+
+    This tool uses Claude Agent SDK to give the research agent direct access to:
+    - Actual Prefect source code via Read tool
+    - Code search via Grep/Bash (rg)
+    - File discovery via Glob
+    - Shell commands for exploration
+
+    This eliminates hallucination by allowing the agent to verify everything
+    against the actual implementation.
+
+    Args:
+        question: The specific question or topic to research
+        topic: A short display name for the topic based on the question (for bookkeeping)
+        version: Prefect version ("2.x" or "3.x")
+    """
+    try:
+        result = (
+            task(task_run_name=f"Researching {topic}", cache_policy=INPUTS)(
+                research_topic_with_code_access
+            )
+            .submit(question, version)
+            .result()
+        )
+
+        return f"**Research Findings (Code-Verified)**\n\n{result}"
+
+    except Exception as e:
+        return f"Research failed: {str(e)}. The agent may not have access to the source code."

{marvin-3.2.2 → marvin-3.2.4}/examples/timeseries.py

@@ -2,9 +2,9 @@ import json
 import re
 from typing import Any, TypedDict
 
-from atproto import Client
+from atproto import Client, models
 from atproto.exceptions import BadRequestError
-from atproto_client.models.app.bsky.feed.defs import ThreadViewPost
+from pydantic import field_validator
 from pydantic_ai import ImageUrl
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
@@ -21,6 +21,15 @@ class Settings(BaseSettings):
 
     bsky_handle: str
     bsky_password: str
+    atproto_pds_url: str = "https://bsky.social"
+
+    @field_validator("atproto_pds_url")
+    @classmethod
+    def ensure_url_protocol(cls, v: str) -> str:
+        """Ensure the PDS URL has a protocol"""
+        if not v.startswith(("http://", "https://")):
+            return f"https://{v}"
+        return v
 
 
 class Snapshot(TypedDict):
@@ -48,7 +57,7 @@ def extract_post_id(bluesky_url: str) -> tuple[str, str]:
     return match.group(1), match.group(2)
 
 
-def build_context(thread: ThreadViewPost) -> dict[str, Any]:
+def build_context(thread: models.AppBskyFeedDefs.ThreadViewPost) -> dict[str, Any]:
     context: dict[str, Any] = {}
     if thread and thread.post:
         context["bsky post"] = {
@@ -65,7 +74,7 @@ def build_context(thread: ThreadViewPost) -> dict[str, Any]:
             image_description_result = visual_extraction_agent.run(
                 [
                     "summarize this image concisely, include direct quotes from the image",
-                    ImageUrl(url=img.fullsize),
+                    ImageUrl(url=img.fullsize, media_type="image/jpeg"),
                 ]
             )
             context["bsky post"]["embed"] = image_description_result
@@ -80,7 +89,10 @@ def build_context(thread: ThreadViewPost) -> dict[str, Any]:
                             "embed": visual_extraction_agent.run(
                                 "summarize this image concisely, include direct quotes from the image",
                                 attachments=[
-                                    ImageUrl(url=reply_post.embed.images[0].fullsize),
+                                    ImageUrl(
+                                        url=reply_post.embed.images[0].fullsize,
+                                        media_type="image/jpeg",
+                                    ),
                                 ],
                             )
                         }
@@ -99,7 +111,7 @@ def build_context(thread: ThreadViewPost) -> dict[str, Any]:
 def explain_bsky_post(
     bsky_post_url: str, details: dict[str, Any] | None = None
 ) -> None:
-    client = Client()
+    client = Client(base_url=settings.atproto_pds_url)
     client.login(settings.bsky_handle, settings.bsky_password)
 
     try:
@@ -111,7 +123,7 @@ def explain_bsky_post(
         logger.error(f"Error fetching thread: {e}")
         return
 
-    assert isinstance(thread, ThreadViewPost)
+    assert isinstance(thread, models.AppBskyFeedDefs.ThreadViewPost)
     context = build_context(thread)
 
     if details:

{marvin-3.2.2 → marvin-3.2.4}/pyproject.toml

@@ -10,7 +10,7 @@ dependencies = [
     "alembic>=1.12.0",
     "jinja2>=3.1.4",
     "partial-json-parser>=0.2.1.1.post5",
-    "pydantic-ai>=0.7.2",
+    "pydantic-ai>=1.9.0",
     "pydantic-settings>=2.6.1",
     "pydantic[email]>=2.10.6",
     "rich>=13.9.4",

{marvin-3.2.2 → marvin-3.2.4}/src/marvin/database.py

@@ -416,14 +416,17 @@ def _run_migrations(alembic_log_level: str = "WARNING") -> bool:
         return False
 
 
-async def create_db_and_tables(*, force: bool = False) -> None:
-    """Create all database tables synchronously.
-
-    This is a synchronous alternative to create_db_and_tables() that can be used
-    in contexts where asyncio.run() cannot be called.
+async def create_db_and_tables(
+    *, force: bool = False, dispose_engine: bool = False
+) -> None:
+    """Create all database tables.
 
     Args:
         force: If True, drops all existing tables before creating new ones.
+        dispose_engine: If True, dispose the engine after creating tables.
+            This is useful when called from asyncio.run() to ensure the
+            aiosqlite worker thread is cleaned up and doesn't prevent
+            Python from exiting.
     """
     engine = get_async_engine()
 
@@ -435,6 +438,15 @@ async def create_db_and_tables(*, force: bool = False) -> None:
         await conn.run_sync(Base.metadata.create_all)
         logger.debug("Database tables created.")
 
+    if dispose_engine:
+        await engine.dispose()
+        # Remove the engine from the cache since it's disposed
+        try:
+            loop = asyncio.get_running_loop()
+        except RuntimeError:
+            loop = None
+        _async_engine_cache.pop(loop, None)
+
 
 def init_database_if_necessary():
     """Initialize the database file if necessary.
@@ -543,7 +555,10 @@ def ensure_db_tables_exist():
     # Create tables synchronously using asyncio.run() if we're not in an async context
     try:
         with _create_tables_lock:
-            asyncio.run(create_db_and_tables())
+            # Use dispose_engine=True to clean up the aiosqlite worker thread
+            # after table creation. Without this, the cached engine's worker
+            # thread could prevent Python from exiting cleanly.
+            asyncio.run(create_db_and_tables(dispose_engine=True))
             logger.debug("Database tables created successfully.")
     except Exception as e:
         logger.error(f"Failed to create database tables: {e}")

{marvin-3.2.2 → marvin-3.2.4}/src/marvin/engine/streaming.py

@@ -10,6 +10,7 @@ from pydantic_ai.messages import (
     FunctionToolResultEvent,
     ModelResponsePart,
     PartDeltaEvent,
+    PartEndEvent,
     PartStartEvent,
     RetryPromptPart,
     TextPartDelta,
@@ -236,6 +237,13 @@ def _process_pydantic_event(
                 tool_call_id=snapshot.tool_call_id if snapshot else None,
                 tool=tools_map.get(event.part.tool_name),
             )
+    # Handle Part End Events
+    elif isinstance(event, PartEndEvent):
+        # Part end events signal that a part is complete. We don't need to
+        # emit a Marvin event for this since we handle completion via other
+        # events (FunctionToolCallEvent, FinalResultEvent, etc.)
+        return None
+
     # Handle Part Delta Events
     elif isinstance(event, PartDeltaEvent):
         # Process a delta update to an existing part