planar 0.9.3__py3-none-any.whl → 0.11.0__py3-none-any.whl

planar/routers/test_agents_router.py

@@ -1,174 +0,0 @@
-"""
-Tests for agent router endpoints.
-
-This module tests the agent router endpoints to ensure they work correctly
-with the new serialization changes.
-"""
-
-import pytest
-from sqlmodel.ext.asyncio.session import AsyncSession
-
-from planar.ai.agent import Agent
-from planar.app import PlanarApp
-from planar.config import sqlite_config
-from planar.testing.planar_test_client import PlanarTestClient
-
-
-@pytest.fixture(name="app")
-def app_fixture(tmp_db_path: str):
-    """Create a test app with agents."""
-    app = PlanarApp(
-        config=sqlite_config(tmp_db_path),
-        title="Test app for agent router",
-        description="Testing agent endpoints",
-    )
-
-    # Register a simple agent
-    simple_agent = Agent(
-        name="simple_test_agent",
-        system_prompt="Simple system prompt",
-        user_prompt="Simple user prompt: {input}",
-        model="openai:gpt-4o",
-        max_turns=2,
-    )
-    app.register_agent(simple_agent)
-
-    # Register an agent with tools
-    async def test_tool(param: str) -> str:
-        """A test tool."""
-        return f"Processed: {param}"
-
-    agent_with_tools = Agent(
-        name="agent_with_tools",
-        system_prompt="System with tools",
-        user_prompt="User: {input}",
-        model="anthropic:claude-3-5-sonnet-latest",
-        max_turns=5,
-        tools=[test_tool],
-    )
-    app.register_agent(agent_with_tools)
-
-    return app
-
-
-async def test_get_agents_endpoint(
-    client: PlanarTestClient, app: PlanarApp, session: AsyncSession
-):
-    """Test the GET /agents endpoint returns agents with configs field."""
-    response = await client.get("/planar/v1/agents/")
-    assert response.status_code == 200
-
-    agents = response.json()
-    assert len(agents) == 2
-
-    # Check first agent
-    simple_agent = next(a for a in agents if a["name"] == "simple_test_agent")
-    assert simple_agent["name"] == "simple_test_agent"
-    assert "configs" in simple_agent
-    assert isinstance(simple_agent["configs"], list)
-    assert len(simple_agent["configs"]) == 1  # Default config always present
-
-    # Verify the default config is present and correct
-    default_config = simple_agent["configs"][-1]
-    assert default_config["version"] == 0
-    assert default_config["data"]["system_prompt"] == "Simple system prompt"
-    assert default_config["data"]["user_prompt"] == "Simple user prompt: {input}"
-    assert default_config["data"]["model"] == "openai:gpt-4o"
-    assert default_config["data"]["max_turns"] == 2
-
-    # Verify removed fields are not present
-    assert "system_prompt" not in simple_agent
-    assert "user_prompt" not in simple_agent
-    assert "model" not in simple_agent
-    assert "max_turns" not in simple_agent
-    assert "overwrites" not in simple_agent
-
-    # Check agent with tools
-    tools_agent = next(a for a in agents if a["name"] == "agent_with_tools")
-    assert len(tools_agent["tool_definitions"]) == 1
-    assert tools_agent["tool_definitions"][0]["name"] == "test_tool"
-
-
-async def test_update_agent_endpoint(
-    client: PlanarTestClient, app: PlanarApp, session: AsyncSession
-):
-    """Test the PATCH /agents/{agent_name} endpoint creates configs."""
-    # Get agents first
-    response = await client.get("/planar/v1/agents/")
-    assert response.status_code == 200
-    agents = response.json()
-    assert len(agents) == 2
-
-    # Update the agent
-    update_data = {
-        "system_prompt": "Updated system prompt",
-        "user_prompt": "Updated user prompt: {input}",
-    }
-    response = await client.patch(
-        "/planar/v1/agents/simple_test_agent", json=update_data
-    )
-    assert response.status_code == 200
-
-    updated_agent = response.json()
-    assert "configs" in updated_agent
-    assert len(updated_agent["configs"]) == 2
-
-    # Check the config data
-    config = updated_agent["configs"][0]
-    assert config["data"]["system_prompt"] == "Updated system prompt"
-    assert config["data"]["user_prompt"] == "Updated user prompt: {input}"
-    assert config["version"] == 1
-    assert config["object_type"] == "agent"
-    assert config["object_name"] == "simple_test_agent"
-
-
-async def test_agent_with_multiple_configs(
-    client: PlanarTestClient, app: PlanarApp, session: AsyncSession
-):
-    """Test that agents return all configs when multiple exist."""
-    # Get the agent ID first
-    response = await client.get("/planar/v1/agents/")
-    agents = response.json()
-    simple_agent = next(a for a in agents if a["name"] == "simple_test_agent")
-
-    # Create first config via PATCH endpoint
-    config1_data = {
-        "system_prompt": "Config 1 system",
-        "user_prompt": "Config 1 user: {input}",
-        "model": "openai:gpt-4o",
-        "max_turns": 2,
-        "model_parameters": {"temperature": 0.7},
-    }
-    response = await client.patch(
-        f"/planar/v1/agents/{simple_agent['name']}", json=config1_data
-    )
-    assert response.status_code == 200
-
-    # Create second config via PATCH endpoint
-    config2_data = {
-        "system_prompt": "Config 2 system",
-        "user_prompt": "Config 2 user: {input}",
-        "model": "anthropic:claude-3-opus",
-        "max_turns": 4,
-        "model_parameters": {"temperature": 0.9},
-    }
-    response = await client.patch(
-        f"/planar/v1/agents/{simple_agent['name']}", json=config2_data
-    )
-    assert response.status_code == 200
-
-    # Get agents
-    response = await client.get("/planar/v1/agents/")
-    agents = response.json()
-    simple_agent = next(a for a in agents if a["name"] == "simple_test_agent")
-
-    # Verify all configs are returned (including default config)
-    assert len(simple_agent["configs"]) == 3
-    assert simple_agent["configs"][0]["version"] == 2  # Latest first
-    assert simple_agent["configs"][1]["version"] == 1
-    assert simple_agent["configs"][2]["version"] == 0  # Default config
-
-    # Verify config data
-    assert simple_agent["configs"][0]["data"]["system_prompt"] == "Config 2 system"
-    assert simple_agent["configs"][1]["data"]["system_prompt"] == "Config 1 system"
-    assert simple_agent["configs"][2]["data"]["system_prompt"] == "Simple system prompt"

planar/routers/test_files_router.py

@@ -1,49 +0,0 @@
-import io
-from uuid import UUID
-
-import pytest
-from sqlmodel.ext.asyncio.session import AsyncSession
-
-from planar import PlanarApp, sqlite_config
-from planar.files.models import PlanarFileMetadata
-from planar.testing.planar_test_client import PlanarTestClient
-
-
-@pytest.fixture(name="app")
-def app_fixture(tmp_db_path: str):
-    return PlanarApp(
-        config=sqlite_config(tmp_db_path),
-        title="Test app for files router",
-        description="Testing files endpoints",
-    )
-
-
-async def test_upload_parquet_sets_content_type(
-    client: PlanarTestClient, session: AsyncSession
-):
-    """Uploading a .parquet file should persist application/x-parquet in metadata."""
-
-    # Prepare a small in-memory payload and intentionally send an octet-stream
-    # to simulate browsers that don't know parquet. The route should override
-    # this using mimetypes.guess_type.
-    filename = "test_data.parquet"
-    payload = b"PAR1"  # content doesn't matter for MIME guessing by filename
-
-    files = {
-        "files": (filename, io.BytesIO(payload), "application/octet-stream"),
-    }
-
-    resp = await client.post("/planar/v1/file/upload", files=files)
-    assert resp.status_code == 200
-
-    body = resp.json()
-    assert isinstance(body, list) and len(body) == 1
-    file_item = body[0]
-    assert file_item["filename"] == filename
-
-    # Verify the database record has the correct MIME type
-    file_id = UUID(file_item["id"])
-    meta = await session.get(PlanarFileMetadata, file_id)
-
-    assert meta is not None
-    assert meta.content_type == "application/x-parquet"

planar/routers/test_object_config_router.py

@@ -1,367 +0,0 @@
-"""
-Tests for object configuration router endpoints.
-
-This module tests the object configuration router endpoints to ensure they work correctly
-for both agent and rule configurations.
-"""
-
-from typing import AsyncGenerator
-from uuid import UUID, uuid4
-
-import pytest
-from pydantic import BaseModel, Field
-from sqlmodel.ext.asyncio.session import AsyncSession
-
-from planar.ai.agent import Agent
-from planar.ai.agent_utils import agent_configuration
-from planar.ai.models import AgentConfig
-from planar.app import PlanarApp
-from planar.config import sqlite_config
-from planar.object_config import DEFAULT_UUID, ObjectConfiguration
-from planar.object_config.object_config import ConfigurableObjectType
-from planar.object_registry import ObjectRegistry
-from planar.rules.decorator import rule
-from planar.rules.models import Rule, RuleEngineConfig, create_jdm_graph
-from planar.rules.rule_configuration import rule_configuration
-from planar.testing.planar_test_client import PlanarTestClient
-
-
-class InputForTestRule(BaseModel):
-    """Input for test rule."""
-
-    value: int = Field(description="Test value")
-    category: str = Field(description="Test category")
-
-
-class OutputFromTestRule(BaseModel):
-    """Output from test rule."""
-
-    result: int = Field(description="Result value")
-    message: str = Field(description="Result message")
-
-
-@pytest.fixture(name="app")
-def app_fixture(tmp_db_path: str):
-    """Create a test app with agents and rules."""
-    app = PlanarApp(
-        config=sqlite_config(tmp_db_path),
-        title="Test app for object config router",
-        description="Testing object configuration endpoints",
-    )
-
-    # Register a simple agent
-    simple_agent = Agent(
-        name="test_agent",
-        system_prompt="Test system prompt",
-        user_prompt="Test user prompt: {input}",
-        model="openai:gpt-4o",
-        max_turns=2,
-    )
-    app.register_agent(simple_agent)
-
-    # Create and register a rule
-    @rule(description="Test rule for configuration")
-    def test_rule(input: InputForTestRule) -> OutputFromTestRule:
-        # Default implementation
-        return OutputFromTestRule(
-            result=input.value * 2, message=f"Processed {input.category}"
-        )
-
-    app.register_rule(test_rule)
-
-    return app
-
-
-@pytest.fixture
-async def agent_with_configs(app: PlanarApp, session: AsyncSession):
-    """Create an agent with multiple configurations."""
-    # First config
-    agent_config_1 = AgentConfig(
-        system_prompt="Config 1 system",
-        user_prompt="Config 1 user: {input}",
-        model="openai:gpt-4o",
-        max_turns=3,
-    )
-    await agent_configuration.write_config("test_agent", agent_config_1)
-
-    # Second config
-    agent_config_2 = AgentConfig(
-        system_prompt="Config 2 system",
-        user_prompt="Config 2 user: {input}",
-        model="anthropic:claude-3-sonnet",
-        max_turns=5,
-    )
-    config_2 = await agent_configuration.write_config("test_agent", agent_config_2)
-
-    # Make the second config active
-    await agent_configuration.promote_config(config_2.id)
-
-    return config_2.id
-
-
-@pytest.fixture
-async def rule_with_configs(
-    session: AsyncSession,
-) -> AsyncGenerator[tuple[Rule, list[ObjectConfiguration]], None]:
-    class RuleInputOutput(BaseModel):
-        test: str
-
-    rule = Rule(
-        name=f"test_rule_promote_{uuid4().hex}",
-        description="Test rule for promoting configuration",
-        input=RuleInputOutput,
-        output=RuleInputOutput,
-    )
-    ObjectRegistry.get_instance().register(rule)
-
-    # Create some configs
-    jdm_config_1 = create_jdm_graph(rule)
-    jdm_config_2 = create_jdm_graph(rule)
-
-    rule_config_1 = RuleEngineConfig(jdm=jdm_config_1)
-    rule_config_2 = RuleEngineConfig(jdm=jdm_config_2)
-
-    config1 = await rule_configuration.write_config(rule.name, rule_config_1)
-    config2 = await rule_configuration.write_config(rule.name, rule_config_2)
-
-    yield rule, [config1, config2]
-
-
-async def test_promote_agent_config(
-    client: PlanarTestClient,
-    app: PlanarApp,
-    session: AsyncSession,
-    agent_with_configs: UUID,
-):
-    """Test promoting an agent configuration."""
-    # Get the configurations first to find a non-active one
-    agent = app._object_registry.get_agents()[0]
-    configs = await agent_configuration.read_configs_with_default(
-        "test_agent", agent.to_config()
-    )
-
-    # Find the first (inactive) config
-    inactive_config = next(c for c in configs if not c.active)
-
-    # Promote the inactive config
-    request_data = {
-        "object_type": ConfigurableObjectType.AGENT,
-        "config_id": str(inactive_config.id),
-        "object_name": "test_agent",
-    }
-
-    response = await client.post(
-        "/planar/v1/object-configurations/promote", json=request_data
-    )
-    assert response.status_code == 200
-
-    result = response.json()
-    assert "configs" in result
-    assert len(result["configs"]) >= 3  # At least 2 configs + default
-
-    # Verify the promoted config is now active
-    promoted_config = next(
-        c for c in result["configs"] if c["id"] == str(inactive_config.id)
-    )
-    assert promoted_config["active"] is True
-
-    # Verify other configs are inactive
-    for config in result["configs"]:
-        if config["id"] != str(inactive_config.id):
-            assert config["active"] is False
-
-
-async def test_promote_rule_config(
-    client: PlanarTestClient,
-    app: PlanarApp,
-    session: AsyncSession,
-):
-    """Test promoting a rule configuration."""
-    # Get the configurations first to find a non-active one
-    rule = ObjectRegistry.get_instance().get_rules()[0]
-
-    await rule_configuration.write_config(
-        rule.name, RuleEngineConfig(jdm=create_jdm_graph(rule))
-    )
-
-    configs = await rule_configuration.read_configs_with_default(
-        rule.name, rule.to_config()
-    )
-
-    assert len(configs) == 2
-
-    # Find the first (inactive) config
-    inactive_config = next(c for c in configs if not c.active)
-
-    # Promote the inactive config
-    request_data = {
-        "object_type": ConfigurableObjectType.RULE,
-        "config_id": str(inactive_config.id),
-        "object_name": rule.name,
-    }
-
-    response = await client.post(
-        "/planar/v1/object-configurations/promote", json=request_data
-    )
-    assert response.status_code == 200
-
-    result = response.json()
-    assert "configs" in result
-    assert len(result["configs"]) == 2
-
-    # Verify the promoted config is now active
-    promoted_config = next(
-        c for c in result["configs"] if c["id"] == str(inactive_config.id)
-    )
-    assert promoted_config["active"] is True
-
-    # Verify the config data is correct
-    assert promoted_config["object_type"] == "rule"
-    assert promoted_config["object_name"] == rule.name
-    assert "jdm" in promoted_config["data"]
-
-
-async def test_promote_to_default_agent(
-    client: PlanarTestClient,
-    app: PlanarApp,
-    session: AsyncSession,
-    agent_with_configs: UUID,
-):
-    """Test promoting to default (revert to original implementation) for agent."""
-    # Promote to default using the special UUID
-    request_data = {
-        "object_type": ConfigurableObjectType.AGENT,
-        "config_id": str(DEFAULT_UUID),
-        "object_name": "test_agent",
-    }
-
-    response = await client.post(
-        "/planar/v1/object-configurations/promote", json=request_data
-    )
-    assert response.status_code == 200
-
-    result = response.json()
-    assert "configs" in result
-
-    # Verify all non-default configs are inactive
-    for config in result["configs"]:
-        if config["version"] == 0:  # Default config
-            assert config["active"] is True
-        else:
-            assert config["active"] is False
-
-
-async def test_promote_to_default_rule(
-    client: PlanarTestClient,
-    app: PlanarApp,
-    session: AsyncSession,
-    rule_with_configs: UUID,
-):
-    """Test promoting to default (revert to original implementation) for rule."""
-    # Promote to default using the special UUID
-    request_data = {
-        "object_type": ConfigurableObjectType.RULE,
-        "config_id": str(DEFAULT_UUID),
-        "object_name": "test_rule",
-    }
-
-    response = await client.post(
-        "/planar/v1/object-configurations/promote", json=request_data
-    )
-    assert response.status_code == 200
-
-    result = response.json()
-    assert "configs" in result
-
-    # Verify all non-default configs are inactive
-    for config in result["configs"]:
-        if config["version"] == 0:  # Default config
-            assert config["active"] is True
-        else:
-            assert config["active"] is False
-
-
-async def test_promote_nonexistent_agent(
-    client: PlanarTestClient, app: PlanarApp, session: AsyncSession
-):
-    """Test promoting config for non-existent agent."""
-    request_data = {
-        "object_type": ConfigurableObjectType.AGENT,
-        "config_id": str(UUID("12345678-1234-5678-1234-567812345678")),
-        "object_name": "nonexistent_agent",
-    }
-
-    response = await client.post(
-        "/planar/v1/object-configurations/promote", json=request_data
-    )
-    assert response.status_code == 404
-    assert response.json()["detail"] == "Agent not found"
-
-
-async def test_promote_nonexistent_rule(
-    client: PlanarTestClient, app: PlanarApp, session: AsyncSession
-):
-    """Test promoting config for non-existent rule."""
-    request_data = {
-        "object_type": ConfigurableObjectType.RULE,
-        "config_id": str(UUID("12345678-1234-5678-1234-567812345678")),
-        "object_name": "nonexistent_rule",
-    }
-
-    response = await client.post(
-        "/planar/v1/object-configurations/promote", json=request_data
-    )
-    assert response.status_code == 404
-    assert response.json()["detail"] == "Rule not found"
-
-
-async def test_promote_nonexistent_config(
-    client: PlanarTestClient,
-    app: PlanarApp,
-    session: AsyncSession,
-    agent_with_configs: UUID,
-):
-    """Test promoting a non-existent configuration."""
-    # Try to promote a config that doesn't exist
-    request_data = {
-        "object_type": ConfigurableObjectType.AGENT,
-        "config_id": str(UUID("99999999-9999-9999-9999-999999999999")),
-        "object_name": "test_agent",
-    }
-
-    # This should fail with an error from the promote_config method
-    response = await client.post(
-        "/planar/v1/object-configurations/promote", json=request_data
-    )
-    assert response.status_code == 404
-
-
-async def test_config_versions_ordering(
-    client: PlanarTestClient,
-    app: PlanarApp,
-    session: AsyncSession,
-    agent_with_configs: UUID,
-):
-    """Test that configurations are returned in correct version order."""
-    # Promote to ensure we have a known state
-    request_data = {
-        "object_type": ConfigurableObjectType.AGENT,
-        "config_id": str(agent_with_configs),
-        "object_name": "test_agent",
-    }
-
-    response = await client.post(
-        "/planar/v1/object-configurations/promote", json=request_data
-    )
-    assert response.status_code == 200
-
-    result = response.json()
-    configs = result["configs"]
-
-    # Verify configs are ordered by version descending (except default which is always last)
-    non_default_configs = [c for c in configs if c["version"] != 0]
-    versions = [c["version"] for c in non_default_configs]
-    assert versions == sorted(versions, reverse=True)
-
-    # Verify default config is last
-    assert configs[-1]["version"] == 0