agentex-sdk 0.1.1__py3-none-any.whl → 0.2.1__py3-none-any.whl

agentex/_version.py

@@ -1,4 +1,4 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 __title__ = "agentex"
-__version__ = "0.1.1"  # x-release-please-version
+__version__ = "0.2.1"  # x-release-please-version

agentex/lib/adk/_modules/messages.py

@@ -3,7 +3,7 @@ from datetime import timedelta
 from temporalio.common import RetryPolicy
 
 from agentex import AsyncAgentex
-from agentex.lib.core.adapters.streams.adapter_redis import RedisEventStreamRepository
+from agentex.lib.core.adapters.streams.adapter_redis import RedisStreamRepository
 from agentex.lib.core.services.adk.messages import MessagesService
 from agentex.lib.core.services.adk.streaming import StreamingService
 from agentex.lib.core.temporal.activities.activity_helpers import ActivityHelpers
@@ -38,7 +38,7 @@ class MessagesModule:
     ):
         if messages_service is None:
             agentex_client = AsyncAgentex()
-            stream_repository = RedisEventStreamRepository()
+            stream_repository = RedisStreamRepository()
             streaming_service = StreamingService(
                 agentex_client=agentex_client,
                 stream_repository=stream_repository,

agentex/lib/adk/_modules/streaming.py

@@ -1,7 +1,7 @@
 from temporalio.common import RetryPolicy
 
 from agentex import AsyncAgentex
-from agentex.lib.core.adapters.streams.adapter_redis import RedisEventStreamRepository
+from agentex.lib.core.adapters.streams.adapter_redis import RedisStreamRepository
 from agentex.lib.core.services.adk.streaming import (
     StreamingService,
     StreamingTaskMessageContext,
@@ -33,7 +33,7 @@ class StreamingModule:
                 a new service will be created with default parameters.
         """
         if streaming_service is None:
-            stream_repository = RedisEventStreamRepository()
+            stream_repository = RedisStreamRepository()
             agentex_client = AsyncAgentex()
             self._streaming_service = StreamingService(
                 agentex_client=agentex_client,

agentex/lib/adk/providers/_modules/litellm.py

@@ -5,7 +5,7 @@ from temporalio.common import RetryPolicy
 
 from agentex import AsyncAgentex
 from agentex.lib.core.adapters.llm.adapter_litellm import LiteLLMGateway
-from agentex.lib.core.adapters.streams.adapter_redis import RedisEventStreamRepository
+from agentex.lib.core.adapters.streams.adapter_redis import RedisStreamRepository
 from agentex.lib.core.services.adk.providers.litellm import LiteLLMService
 from agentex.lib.core.services.adk.streaming import StreamingService
 from agentex.lib.core.temporal.activities.activity_helpers import ActivityHelpers
@@ -40,7 +40,7 @@ class LiteLLMModule:
         if litellm_service is None:
             # Create default service
             agentex_client = AsyncAgentex()
-            stream_repository = RedisEventStreamRepository()
+            stream_repository = RedisStreamRepository()
             streaming_service = StreamingService(
                 agentex_client=agentex_client,
                 stream_repository=stream_repository,

agentex/lib/adk/providers/_modules/openai.py

@@ -10,7 +10,7 @@ from mcp import StdioServerParameters
 from temporalio.common import RetryPolicy
 
 from agentex import AsyncAgentex
-from agentex.lib.core.adapters.streams.adapter_redis import RedisEventStreamRepository
+from agentex.lib.core.adapters.streams.adapter_redis import RedisStreamRepository
 from agentex.lib.core.services.adk.providers.openai import OpenAIService
 from agentex.lib.core.services.adk.streaming import StreamingService
 from agentex.lib.core.temporal.activities.activity_helpers import ActivityHelpers
@@ -47,7 +47,7 @@ class OpenAIModule:
         if openai_service is None:
             # Create default service
             agentex_client = AsyncAgentex()
-            stream_repository = RedisEventStreamRepository()
+            stream_repository = RedisStreamRepository()
             streaming_service = StreamingService(
                 agentex_client=agentex_client,
                 stream_repository=stream_repository,

agentex/lib/cli/commands/init.py

@@ -1,5 +1,6 @@
 from enum import Enum
 from pathlib import Path
+from typing import Any, Dict
 
 import questionary
 from jinja2 import Environment, FileSystemLoader
@@ -23,7 +24,7 @@ class TemplateType(str, Enum):
 
 
 def render_template(
-    template_path: str, context: dict, template_type: TemplateType
+    template_path: str, context: Dict[str, Any], template_type: TemplateType
 ) -> str:
     """Render a template with the given context"""
     env = Environment(loader=FileSystemLoader(TEMPLATES_DIR / template_type.value))
@@ -32,7 +33,7 @@ def render_template(
 
 
 def create_project_structure(
-    path: Path, context: dict, template_type: TemplateType, use_uv: bool
+    path: Path, context: Dict[str, Any], template_type: TemplateType, use_uv: bool
 ):
     """Create the project structure from templates"""
     # Create project directory
@@ -74,6 +75,9 @@ def create_project_structure(
         root_templates["requirements.txt.j2"] = "requirements.txt"
         root_templates["Dockerfile.j2"] = "Dockerfile"
 
+    # Add development notebook for agents
+    root_templates["dev.ipynb.j2"] = "dev.ipynb"
+
     for template, output in root_templates.items():
         output_path = project_dir / output
         output_path.write_text(render_template(template, context, template_type))
@@ -81,7 +85,7 @@ def create_project_structure(
     console.print(f"\n[green]✓[/green] Created project structure at: {project_dir}")
 
 
-def get_project_context(answers: dict, project_path: Path, manifest_root: Path) -> dict:
+def get_project_context(answers: Dict[str, Any], project_path: Path, manifest_root: Path) -> Dict[str, Any]:
     """Get the project context from user answers"""
     # Use agent_directory_name as project_name
     project_name = answers["agent_directory_name"].replace("-", "_")
@@ -112,7 +116,7 @@ def init():
     )
 
     # Use a Rich table for template descriptions
-    table = Table(show_header=True, header_style="bold magenta")
+    table = Table(show_header=True, header_style="bold blue")
     table.add_column("Template", style="cyan", no_wrap=True)
     table.add_column("Description", style="white")
     table.add_row(

agentex/lib/cli/handlers/deploy_handlers.py

@@ -8,8 +8,10 @@ import yaml
 from pydantic import BaseModel, Field
 from rich.console import Console
 
+from agentex.lib.cli.utils.auth_utils import _encode_principal_context
 from agentex.lib.cli.utils.exceptions import DeploymentError, HelmError
 from agentex.lib.cli.utils.kubectl_utils import check_and_switch_cluster_context
+from agentex.lib.environment_variables import EnvVarKeys
 from agentex.lib.sdk.config.agent_config import AgentConfig
 from agentex.lib.sdk.config.agent_manifest import AgentManifest
 from agentex.lib.sdk.config.deployment_config import ClusterConfig
@@ -92,6 +94,12 @@ def load_override_config(override_file_path: str | None = None) -> ClusterConfig
         ) from e
 
 
+
+def convert_env_vars_dict_to_list(env_vars: dict[str, str]) -> list[dict[str, str]]:
+    """Convert a dictionary of environment variables to a list of dictionaries"""
+    return [{"name": key, "value": value} for key, value in env_vars.items()]
+
+
 def merge_deployment_configs(
     manifest: AgentManifest,
     cluster_config: ClusterConfig | None,
@@ -168,6 +176,10 @@ def merge_deployment_configs(
         if TEMPORAL_WORKER_KEY in helm_values:
             helm_values[TEMPORAL_WORKER_KEY]["env"] = agent_config.env
 
+        encoded_principal = _encode_principal_context(manifest)
+        if encoded_principal:
+            helm_values["env"][EnvVarKeys.AUTH_PRINCIPAL_B64] = encoded_principal
+
     if manifest.deployment and manifest.deployment.imagePullSecrets:
         pull_secrets = [
             pull_secret.to_dict()
@@ -213,6 +225,14 @@ def merge_deployment_configs(
         if cluster_config.additional_overrides:
             _deep_merge(helm_values, cluster_config.additional_overrides)
 
+    # Convert the env vars to a list of dictionaries
+    if "env" in helm_values:
+        helm_values["env"] = convert_env_vars_dict_to_list(helm_values["env"])
+    if TEMPORAL_WORKER_KEY in helm_values and "env" in helm_values[TEMPORAL_WORKER_KEY]:
+        helm_values[TEMPORAL_WORKER_KEY]["env"] = convert_env_vars_dict_to_list(
+            helm_values[TEMPORAL_WORKER_KEY]["env"]
+        )
+    print("Deploying with the following helm values: ", helm_values)
     return helm_values
 
 

agentex/lib/cli/handlers/run_handlers.py

@@ -6,10 +6,12 @@ from pathlib import Path
 from rich.console import Console
 from rich.panel import Panel
 
+from agentex.lib.cli.utils.auth_utils import _encode_principal_context
 from agentex.lib.cli.handlers.cleanup_handlers import (
     cleanup_agent_workflows,
     should_cleanup_on_restart
 )
+from agentex.lib.environment_variables import EnvVarKeys
 from agentex.lib.sdk.config.agent_manifest import AgentManifest
 from agentex.lib.utils.logging import make_logger
 
@@ -427,6 +429,11 @@ def create_agent_environment(manifest: AgentManifest) -> dict[str, str]:
         "ACP_PORT": str(manifest.local_development.agent.port),
     }
 
+    # Add authorization principal if set
+    encoded_principal = _encode_principal_context(manifest)
+    if encoded_principal:
+        env_vars[EnvVarKeys.AUTH_PRINCIPAL_B64] = encoded_principal
+
     # Add description if available
     if manifest.agent.description:
         env_vars["AGENT_DESCRIPTION"] = manifest.agent.description

agentex/lib/cli/templates/default/README.md.j2

@@ -62,6 +62,7 @@ This file is essential for both local development and deployment of your agent.
 │   └── acp.py               # ACP server and event handlers
 ├── Dockerfile               # Container definition
 ├── manifest.yaml            # Deployment config
+├── dev.ipynb                # Development notebook for testing
 {% if use_uv %}
 └── pyproject.toml          # Dependencies (uv)
 {% else %}
@@ -76,7 +77,27 @@ This file is essential for both local development and deployment of your agent.
 - Add your own tools and capabilities
 - Implement custom state management
 
-### 2. Manage Dependencies
+### 2. Test Your Agent with the Development Notebook
+Use the included `dev.ipynb` Jupyter notebook to test your agent interactively:
+
+```bash
+# Start Jupyter notebook (make sure you have jupyter installed)
+jupyter notebook dev.ipynb
+
+# Or use VS Code to open the notebook directly
+code dev.ipynb
+```
+
+The notebook includes:
+- **Setup**: Connect to your local AgentEx backend
+- **Task creation**: Create a new task for the conversation
+- **Event sending**: Send events to the agent and get responses
+- **Async message subscription**: Subscribe to server-side events to receive agent responses
+- **Rich message display**: Beautiful formatting with timestamps and author information
+
+The notebook automatically uses your agent name (`{{ agent_name }}`) and demonstrates the agentic ACP workflow: create task → send event → subscribe to responses.
+
+### 3. Manage Dependencies
 
 {% if use_uv %}
 You chose **uv** for package management. Here's how to work with dependencies:
@@ -115,7 +136,7 @@ pip install -r requirements.txt
 - Wide compatibility
 {% endif %}
 
-### 3. Configure Credentials
+### 4. Configure Credentials
 Options:
 1. Add any required credentials to your manifest.yaml via the `env` section
 2. Export them in your shell: `export OPENAI_API_KEY=...`

agentex/lib/cli/templates/default/dev.ipynb.j2

@@ -0,0 +1,127 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "36834357",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from agentex import Agentex\n",
+    "\n",
+    "client = Agentex(base_url=\"http://localhost:5003\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d1c309d6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "AGENT_NAME = \"{{ agent_name }}\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9f6e6ef0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# (REQUIRED) Create a new task. For Agentic agents, you must create a task for messages to be associated with.\n",
+    "\n",
+    "from typing import cast\n",
+    "import uuid\n",
+    "\n",
+    "from agentex.types import Task\n",
+    "\n",
+    "TASK_ID = str(uuid.uuid4())[:8]\n",
+    "\n",
+    "rpc_response = client.agents.rpc_by_name(\n",
+    "    agent_name=AGENT_NAME,\n",
+    "    method=\"task/create\",\n",
+    "    params={\n",
+    "        \"name\": f\"{TASK_ID}-task\",\n",
+    "        \"params\": {}\n",
+    "    }\n",
+    ")\n",
+    "\n",
+    "task = cast(Task, rpc_response.result)\n",
+    "print(task)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b03b0d37",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Test non streaming response\n",
+    "from typing import cast\n",
+    "from agentex.types import Event\n",
+    "\n",
+    "# The response is expected to be a list of TaskMessage objects, which is a union of the following types:\n",
+    "# - TextContent: A message with just text content   \n",
+    "# - DataContent: A message with JSON-serializable data content\n",
+    "# - ToolRequestContent: A message with a tool request, which contains a JSON-serializable request to call a tool\n",
+    "# - ToolResponseContent: A message with a tool response, which contains response object from a tool call in its content\n",
+    "\n",
+    "# When processing the message/send response, if you are expecting more than TextContent, such as DataContent, ToolRequestContent, or ToolResponseContent, you can process them as well\n",
+    "\n",
+    "rpc_response = client.agents.rpc_by_name(\n",
+    "    agent_name=AGENT_NAME,\n",
+    "    method=\"event/send\",\n",
+    "    params={\n",
+    "        \"content\": {\"type\": \"text\", \"author\": \"user\", \"content\": \"Hello what can you do?\"},\n",
+    "        \"task_id\": task.id,\n",
+    "    }\n",
+    ")\n",
+    "\n",
+    "event = cast(Event, rpc_response.result)\n",
+    "print(event)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a6927cc0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from agentex.lib.utils.dev_tools import subscribe_to_async_task_messages\n",
+    "\n",
+    "task_messages = subscribe_to_async_task_messages(\n",
+    "    client=client,\n",
+    "    task=task, \n",
+    "    only_after_timestamp=event.created_at, \n",
+    "    print_messages=True,\n",
+    "    rich_print=True,\n",
+    "    timeout=5,\n",
+    ")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": ".venv",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

agentex/lib/cli/templates/sync/README.md.j2

@@ -60,6 +60,7 @@ This file is essential for both local development and deployment of your agent.
 │   └── acp.py               # ACP server and event handlers
 ├── Dockerfile               # Container definition
 ├── manifest.yaml            # Deployment config
+├── dev.ipynb                # Development notebook for testing
 {% if use_uv %}
 └── pyproject.toml          # Dependencies (uv)
 {% else %}
@@ -74,7 +75,26 @@ This file is essential for both local development and deployment of your agent.
 - Add your own tools and capabilities
 - Implement custom response generation
 
-### 2. Manage Dependencies
+### 2. Test Your Agent with the Development Notebook
+Use the included `dev.ipynb` Jupyter notebook to test your agent interactively:
+
+```bash
+# Start Jupyter notebook (make sure you have jupyter installed)
+jupyter notebook dev.ipynb
+
+# Or use VS Code to open the notebook directly
+code dev.ipynb
+```
+
+The notebook includes:
+- **Setup**: Connect to your local AgentEx backend
+- **Non-streaming tests**: Send messages and get complete responses
+- **Streaming tests**: Test real-time streaming responses
+- **Task management**: Optional task creation and management
+
+The notebook automatically uses your agent name (`{{ agent_name }}`) and provides examples for both streaming and non-streaming message handling.
+
+### 3. Manage Dependencies
 
 {% if use_uv %}
 You chose **uv** for package management. Here's how to work with dependencies:
@@ -113,7 +133,7 @@ pip install -r requirements.txt
 - Wide compatibility
 {% endif %}
 
-### 3. Configure Credentials
+### 4. Configure Credentials
 Options:
 1. Add any required credentials to your manifest.yaml via the `env` section
 2. Export them in your shell: `export OPENAI_API_KEY=...`

agentex/lib/cli/templates/sync/dev.ipynb.j2

@@ -0,0 +1,181 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "36834357",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from agentex import Agentex\n",
+    "\n",
+    "client = Agentex(base_url=\"http://localhost:5003\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d1c309d6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "AGENT_NAME = \"{{ agent_name }}\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9f6e6ef0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# # (Optional) Create a new task. If you don't create a new task, each message will be sent to a new task. The server will create the task for you.\n",
+    "\n",
+    "# import uuid\n",
+    "\n",
+    "# TASK_ID = str(uuid.uuid4())[:8]\n",
+    "\n",
+    "# rpc_response = client.agents.rpc_by_name(\n",
+    "#     agent_name=AGENT_NAME,\n",
+    "#     method=\"task/create\",\n",
+    "#     params={\n",
+    "#         \"name\": f\"{TASK_ID}-task\",\n",
+    "#         \"params\": {}\n",
+    "#     }\n",
+    "# )\n",
+    "\n",
+    "# task = rpc_response.result\n",
+    "# print(task)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b03b0d37",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Test non streaming response\n",
+    "from typing import List, cast\n",
+    "from agentex.types import TaskMessage, TextContent\n",
+    "\n",
+    "# The response is expected to be a list of TaskMessage objects, which is a union of the following types:\n",
+    "# - TextContent: A message with just text content   \n",
+    "# - DataContent: A message with JSON-serializable data content\n",
+    "# - ToolRequestContent: A message with a tool request, which contains a JSON-serializable request to call a tool\n",
+    "# - ToolResponseContent: A message with a tool response, which contains response object from a tool call in its content\n",
+    "\n",
+    "# When processing the message/send response, if you are expecting more than TextContent, such as DataContent, ToolRequestContent, or ToolResponseContent, you can process them as well\n",
+    "\n",
+    "rpc_response = client.agents.rpc_by_name(\n",
+    "    agent_name=AGENT_NAME,\n",
+    "    method=\"message/send\",\n",
+    "    params={\n",
+    "        \"content\": {\"type\": \"text\", \"author\": \"user\", \"content\": \"Hello what can you do?\"},\n",
+    "        \"stream\": False\n",
+    "    }\n",
+    ")\n",
+    "\n",
+    "# # Extract and print just the text content from the response\n",
+    "# # The response is expected to be a dict with a \"result\" key containing a list of message dicts\n",
+    "if rpc_response and rpc_response.result:\n",
+    "\n",
+    "    # We know that the result of the message/send when stream is set to False will be a list of TaskMessage objects\n",
+    "    task_message_list = cast(List[TaskMessage], rpc_response.result)\n",
+    "    for task_message in rpc_response.result:\n",
+    "        if isinstance(task_message, TaskMessage):\n",
+    "            content = task_message.content\n",
+    "            if isinstance(content, TextContent):\n",
+    "                text = content.content\n",
+    "                print(text)\n",
+    "        else:\n",
+    "            print(f\"Found non-text {type(task_message)} object in response.\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "79688331",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Test streaming response\n",
+    "import json\n",
+    "from agentex.types import AgentRpcResponse\n",
+    "from agentex.types.agent_rpc_result import StreamTaskMessageDelta, StreamTaskMessageFull\n",
+    "from agentex.types.text_delta import TextDelta\n",
+    "from agentex.types.task_message_update import TaskMessageUpdate\n",
+    "\n",
+    "\n",
+    "# The result object of message/send will be a TaskMessageUpdate which is a union of the following types:\n",
+    "# - StreamTaskMessageStart: \n",
+    "#   - An indicator that a streaming message was started, doesn't contain any useful content\n",
+    "# - StreamTaskMessageDelta: \n",
+    "#   - A delta of a streaming message, contains the text delta to aggregate\n",
+    "# - StreamTaskMessageDone: \n",
+    "#   - An indicator that a streaming message was done, doesn't contain any useful content\n",
+    "# - StreamTaskMessageFull: \n",
+    "#   - A non-streaming message, there is nothing to aggregate, since this contains the full message, not deltas\n",
+    "\n",
+    "# Whenn processing StreamTaskMessageDelta, if you are expecting more than TextDeltas, such as DataDelta, ToolRequestDelta, or ToolResponseDelta, you can process them as well\n",
+    "# Whenn processing StreamTaskMessageFull, if you are expecting more than TextContent, such as DataContent, ToolRequestContent, or ToolResponseContent, you can process them as well\n",
+    "\n",
+    "with client.agents.with_streaming_response.rpc_by_name(\n",
+    "    agent_name=AGENT_NAME,\n",
+    "    method=\"message/send\",\n",
+    "    params={\n",
+    "        \"content\": {\"type\": \"text\", \"author\": \"user\", \"content\": \"Hello what can you do?\"},\n",
+    "        \"stream\": True\n",
+    "    }\n",
+    ") as response:\n",
+    "    for agent_rpc_response_str in response.iter_text():\n",
+    "        chunk_rpc_response = AgentRpcResponse.model_validate(json.loads(agent_rpc_response_str))\n",
+    "        # We know that the result of the message/send when stream is set to True will be a TaskMessageUpdate\n",
+    "        task_message_update = cast(TaskMessageUpdate, chunk_rpc_response.result)\n",
+    "\n",
+    "        # Print oly the text deltas as they arrive or any full messages\n",
+    "        if isinstance(task_message_update, StreamTaskMessageDelta):\n",
+    "            delta = task_message_update.delta\n",
+    "            if isinstance(delta, TextDelta):\n",
+    "                print(delta.text_delta, end=\"\", flush=True)\n",
+    "            else:\n",
+    "                print(f\"Found non-text {type(task_message)} object in streaming message.\")\n",
+    "        elif isinstance(task_message_update, StreamTaskMessageFull):\n",
+    "            content = task_message_update.content\n",
+    "            if isinstance(content, TextContent):\n",
+    "                print(content.content)\n",
+    "            else:\n",
+    "                print(f\"Found non-text {type(task_message)} object in full message.\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4ffb663c",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": ".venv",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}