planar 0.5.0__py3-none-any.whl

planar/test_object_config.py

@@ -0,0 +1,527 @@
+"""
+Tests for object configuration schema validation functionality.
+
+Also Tests for the object configuration promotion logic.
+
+This module consolidates tests for the promote_config functionality
+used by the object_config_router, covering both agent and rule configurations.
+"""
+
+from uuid import uuid4
+
+import pytest
+from pydantic import BaseModel
+from sqlmodel import select
+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.object_config import (
+    DEFAULT_UUID,
+    ConfigNotFoundError,
+    ConfigurableObjectType,
+    ObjectConfiguration,
+    ObjectConfigurationIO,
+)
+from planar.object_registry import ObjectRegistry
+from planar.rules.models import Rule, RuleEngineConfig, create_jdm_graph
+from planar.rules.rule_configuration import rule_configuration
+
+
+@pytest.fixture
+def rule_definition():
+    class RuleInputOutput(BaseModel):
+        test: str
+
+    return Rule(
+        name="test_rule_promote_success",
+        description="Test rule for promoting configuration",
+        input=RuleInputOutput,
+        output=RuleInputOutput,
+    )
+
+
+@pytest.fixture
+def agent_definition():
+    class AgentInputOutput(BaseModel):
+        test: str
+
+    return Agent(
+        name="test_agent_promote_success",
+        system_prompt="Test agent for promoting configuration",
+        user_prompt="Test agent for promoting configuration",
+        model="gpt-4",
+        max_turns=1,
+    )
+
+
+class ConfigV1(BaseModel):
+    """Version 1 of a test configuration schema."""
+
+    name: str
+    value: int
+
+
+@pytest.fixture
+def config_io_v1():
+    """Configuration IO for version 1 schema."""
+    return ObjectConfigurationIO(ConfigV1, ConfigurableObjectType.RULE)
+
+
+async def test_schema_validation_success(session: AsyncSession, config_io_v1):
+    """Test that valid configurations are loaded"""
+    # Write a valid V1 configuration
+    config_v1 = ConfigV1(name="test", value=42)
+    await config_io_v1.write_config("test_object", config_v1)
+
+    # Read it back with validation
+    result = await config_io_v1._read_configs("test_object")
+
+    assert len(result) == 1
+    assert result[0].data.name == "test"
+    assert result[0].data.value == 42
+
+
+async def test_no_config_returns_empty_list(session: AsyncSession, config_io_v1):
+    """Test that non-existent configurations return empty list"""
+    result = await config_io_v1._read_configs("nonexistent_object")
+
+    assert len(result) == 0
+
+
+async def test_multiple_versions_ordered_by_version_desc(
+    session: AsyncSession, config_io_v1
+):
+    """Test that multiple configurations are returned ordered by version descending."""
+    # Write multiple configurations
+    config_v1_1 = ConfigV1(name="test1", value=1)
+    config_v1_2 = ConfigV1(name="test2", value=2)
+    config_v1_3 = ConfigV1(name="test3", value=3)
+
+    await config_io_v1.write_config("test_object", config_v1_1)
+    await config_io_v1.write_config("test_object", config_v1_2)
+    await config_io_v1.write_config("test_object", config_v1_3)
+
+    # Read all configurations
+    result = await config_io_v1._read_configs("test_object")
+
+    # Should have 3 configurations, ordered by version descending
+    assert len(result) == 3
+    assert result[0].version == 3  # Latest version first
+    assert result[0].data.name == "test3"
+    assert result[1].version == 2
+    assert result[1].data.name == "test2"
+    assert result[2].version == 1  # Oldest version last
+    assert result[2].data.name == "test1"
+
+
+@pytest.mark.asyncio
+class TestPromoteConfigurationLogic:
+    """Test the promote configuration logic for agents and rules."""
+
+    async def test_promote_rule_config_success(
+        self, session: AsyncSession, rule_definition: Rule
+    ):
+        """Test promoting a rule configuration successfully."""
+        ObjectRegistry.get_instance().register(rule_definition)
+
+        rule_config = RuleEngineConfig(jdm=create_jdm_graph(rule_definition))
+        config = await rule_configuration.write_config(
+            rule_definition.name, rule_config
+        )
+
+        await rule_configuration.promote_config(config.id)
+
+        configs = await rule_configuration.read_configs_with_default(
+            rule_definition.name, rule_definition.to_config()
+        )
+
+        assert len(configs) == 2
+        assert configs[0].active is True
+        assert configs[0].version == 1
+
+        # last config is default
+        assert configs[1].active is False
+        assert configs[1].version == 0
+
+        db_config = (
+            await session.exec(
+                select(ObjectConfiguration).where(ObjectConfiguration.id == config.id)
+            )
+        ).first()
+        assert db_config is not None
+        assert db_config.active is True
+
+    async def test_promote_agent_config_success(
+        self, session: AsyncSession, agent_definition: Agent
+    ):
+        """Test promoting an agent configuration successfully."""
+        object_name = f"test_agent_promote_success_{uuid4().hex}"
+        agent_config = AgentConfig(
+            system_prompt="Sys", user_prompt="User", model="gpt-4", max_turns=1
+        )
+        config = await agent_configuration.write_config(object_name, agent_config)
+
+        await agent_configuration.promote_config(config.id)
+
+        configs = await agent_configuration.read_configs_with_default(
+            object_name, agent_definition.to_config()
+        )
+
+        assert len(configs) == 2
+        assert configs[0].active is True
+        assert configs[0].id == config.id
+
+        db_config = (
+            await session.exec(
+                select(ObjectConfiguration).where(ObjectConfiguration.id == config.id)
+            )
+        ).first()
+        assert db_config is not None
+        assert db_config.active is True
+
+    async def test_promote_switches_active_rule_configs(
+        self, session: AsyncSession, rule_definition: Rule
+    ):
+        """Test that promoting a rule config switches active status correctly."""
+        ObjectRegistry.get_instance().register(rule_definition)
+
+        jdm_graph = create_jdm_graph(rule_definition)
+
+        config1_payload = RuleEngineConfig(jdm=jdm_graph)
+        config2_payload = RuleEngineConfig(jdm=jdm_graph)
+
+        config1 = await rule_configuration.write_config(
+            rule_definition.name, config1_payload
+        )
+        config2 = await rule_configuration.write_config(
+            rule_definition.name, config2_payload
+        )
+
+        await rule_configuration.promote_config(config1.id)
+        await rule_configuration.promote_config(config2.id)
+
+        configs = await rule_configuration.read_configs_with_default(
+            rule_definition.name, rule_definition.to_config()
+        )
+
+        assert len(configs) == 3
+        active_configs = [c for c in configs if c.active]
+        inactive_configs = [c for c in configs if not c.active]
+
+        assert len(active_configs) == 1
+        assert active_configs[0].id == config2.id
+        assert len(inactive_configs) == 2
+        assert inactive_configs[0].id == config1.id
+        assert inactive_configs[1].id == DEFAULT_UUID
+
+        db_config1 = (
+            await session.exec(
+                select(ObjectConfiguration).where(ObjectConfiguration.id == config1.id)
+            )
+        ).first()
+        db_config2 = (
+            await session.exec(
+                select(ObjectConfiguration).where(ObjectConfiguration.id == config2.id)
+            )
+        ).first()
+        assert db_config1 is not None and db_config1.active is False
+        assert db_config2 is not None and db_config2.active is True
+
+    async def test_promote_switches_active_agent_configs(
+        self, session: AsyncSession, agent_definition: Agent
+    ):
+        """Test that promoting an agent config switches active status correctly."""
+        object_name = f"test_agent_switches_active_{uuid4().hex}"
+        config1_payload = AgentConfig(
+            system_prompt="S1", user_prompt="U1", model="m1", max_turns=1
+        )
+        config2_payload = AgentConfig(
+            system_prompt="S2", user_prompt="U2", model="m2", max_turns=2
+        )
+
+        config1 = await agent_configuration.write_config(object_name, config1_payload)
+        config2 = await agent_configuration.write_config(object_name, config2_payload)
+
+        await agent_configuration.promote_config(config1.id)
+        await agent_configuration.promote_config(config2.id)
+
+        configs = await agent_configuration.read_configs_with_default(
+            object_name, agent_definition.to_config()
+        )
+
+        assert len(configs) == 3
+        active_configs = [c for c in configs if c.active]
+        inactive_configs = [c for c in configs if not c.active]
+
+        assert len(active_configs) == 1
+        assert active_configs[0].id == config2.id
+        assert len(inactive_configs) == 2
+
+        db_config1 = (
+            await session.exec(
+                select(ObjectConfiguration).where(ObjectConfiguration.id == config1.id)
+            )
+        ).first()
+        db_config2 = (
+            await session.exec(
+                select(ObjectConfiguration).where(ObjectConfiguration.id == config2.id)
+            )
+        ).first()
+        assert db_config1 is not None and db_config1.active is False
+        assert db_config2 is not None and db_config2.active is True
+
+    async def test_promote_default_rule_config_reverts(
+        self, session: AsyncSession, rule_definition: Rule
+    ):
+        """Test promoting default rule config (UUID all zeros) reverts to original."""
+        ObjectRegistry.get_instance().register(rule_definition)
+        rule_config = RuleEngineConfig(jdm=create_jdm_graph(rule_definition))
+        config = await rule_configuration.write_config(
+            rule_definition.name, rule_config
+        )
+
+        await rule_configuration.promote_config(config.id)
+        db_config_promoted = (
+            await session.exec(
+                select(ObjectConfiguration).where(ObjectConfiguration.id == config.id)
+            )
+        ).first()
+        assert db_config_promoted is not None and db_config_promoted.active is True
+
+        await session.commit()
+
+        await rule_configuration.promote_config(
+            DEFAULT_UUID, object_name=rule_definition.name
+        )
+
+        configs = await rule_configuration.read_configs_with_default(
+            rule_definition.name, rule_definition.to_config()
+        )
+
+        assert len(configs) == 2
+        assert configs[0].version == 1
+        assert configs[1].version == 0
+
+        assert configs[0].active is False
+        assert configs[1].active is True
+
+        db_config_reverted = (
+            await session.exec(
+                select(ObjectConfiguration).where(ObjectConfiguration.id == config.id)
+            )
+        ).first()
+        assert db_config_reverted is not None and db_config_reverted.active is False
+
+    async def test_promote_default_agent_config_reverts(
+        self, session: AsyncSession, agent_definition: Agent
+    ):
+        """Test promoting default agent config (UUID all zeros) reverts."""
+        object_name = f"test_agent_revert_default_{uuid4().hex}"
+        agent_config = AgentConfig(
+            system_prompt="S", user_prompt="U", model="m", max_turns=1
+        )
+        config = await agent_configuration.write_config(object_name, agent_config)
+
+        await agent_configuration.promote_config(config.id)
+        db_config_promoted = (
+            await session.exec(
+                select(ObjectConfiguration).where(ObjectConfiguration.id == config.id)
+            )
+        ).first()
+        assert db_config_promoted is not None and db_config_promoted.active is True
+
+        await session.commit()
+
+        await agent_configuration.promote_config(DEFAULT_UUID, object_name=object_name)
+
+        configs = await agent_configuration.read_configs_with_default(
+            object_name, agent_definition.to_config()
+        )
+
+        assert len(configs) == 2
+
+        assert configs[0].version == 1
+        assert configs[1].version == 0
+
+        assert configs[0].active is False
+        assert configs[1].active is True
+
+        db_config_reverted = (
+            await session.exec(
+                select(ObjectConfiguration).where(ObjectConfiguration.id == config.id)
+            )
+        ).first()
+        assert db_config_reverted is not None and db_config_reverted.active is False
+
+    async def test_promote_nonexistent_config_raises_error(self, session: AsyncSession):
+        """Test promoting a non-existent config ID raises ConfigNotFoundError."""
+        nonexistent_id = uuid4()
+        with pytest.raises(ConfigNotFoundError) as excinfo_rule:
+            await rule_configuration.promote_config(nonexistent_id)
+        assert excinfo_rule.value.invalid_id == nonexistent_id
+        assert excinfo_rule.value.object_type == ConfigurableObjectType.RULE
+
+        with pytest.raises(ConfigNotFoundError) as excinfo_agent:
+            await agent_configuration.promote_config(nonexistent_id)
+        assert excinfo_agent.value.invalid_id == nonexistent_id
+        assert excinfo_agent.value.object_type == ConfigurableObjectType.AGENT
+
+    async def test_promote_default_config_requires_object_name(
+        self, session: AsyncSession
+    ):
+        """Test promoting default UUID requires object_name parameter."""
+        with pytest.raises(
+            ValueError,
+            match="object_name is required when reverting to default configuration",
+        ):
+            await rule_configuration.promote_config(DEFAULT_UUID)
+        with pytest.raises(
+            ValueError,
+            match="object_name is required when reverting to default configuration",
+        ):
+            await agent_configuration.promote_config(DEFAULT_UUID)
+
+    async def test_default_config_is_active_when_no_other_configs_present(
+        self, session: AsyncSession, rule_definition: Rule, agent_definition: Agent
+    ):
+        """Test default config is active when no custom configs exist for the object_name."""
+        object_name_rule = f"nonexistent_rule_for_default_{uuid4().hex}"
+        object_name_agent = f"nonexistent_agent_for_default_{uuid4().hex}"
+
+        configs = await rule_configuration.read_configs_with_default(
+            object_name_rule, rule_definition.to_config()
+        )
+        assert len(configs) == 1
+        assert configs[0].version == 0
+        assert configs[0].active is True
+
+        await agent_configuration.promote_config(
+            DEFAULT_UUID, object_name=object_name_agent
+        )
+        configs = await agent_configuration.read_configs_with_default(
+            object_name_agent, agent_definition.to_config()
+        )
+        assert len(configs) == 1
+        assert configs[0].version == 0
+        assert configs[0].active is True
+
+    async def test_promote_returns_all_configs_ordered(
+        self, session: AsyncSession, agent_definition: Agent
+    ):
+        """Test that promote_config returns all configurations for the object_name, ordered by version."""
+        object_name = f"test_agent_promote_all_ordered_{uuid4().hex}"
+        created_configs = []
+        for i in range(3):
+            config = AgentConfig(
+                system_prompt=f"Config {i}",
+                user_prompt=f"UP {i}",
+                model="m",
+                max_turns=i + 1,
+            )
+            cfg = await agent_configuration.write_config(object_name, config)
+            created_configs.append(cfg)
+
+        # Promote the middle config (chronologically, so it's version 2, index 1 if created_configs is in creation order)
+        # Assuming versions are 1, 2, 3. Created_configs[1] is version 2.
+        # The versions will be 3, 2, 1 in the database after 3 writes.
+        # So created_configs[0] (first written) would be version 1.
+        # created_configs[1] (second written) would be version 2.
+        # created_configs[2] (third written) would be version 3.
+
+        # Let's fetch all configs to be sure about IDs and versions before promoting
+        all_configs_before_promote = (
+            await agent_configuration.read_configs_with_default(
+                object_name, agent_definition.to_config()
+            )
+        )
+        ids_by_version_desc = [
+            c.id for c in all_configs_before_promote
+        ]  # Should be [id_v3, id_v2, id_v1, id_default]
+
+        # Verify that the default config is active by default
+        default_config = all_configs_before_promote[-1]
+        assert default_config.active is True, (
+            "Default config should be active by default"
+        )
+
+        # Promote the one that corresponds to original version 2 (second created)
+        # This ID would be ids_by_version_desc[1]
+        config_to_promote_id = ids_by_version_desc[1]
+
+        await agent_configuration.promote_config(config_to_promote_id)
+
+        all_configs_after_promote = await agent_configuration.read_configs_with_default(
+            object_name, agent_definition.to_config()
+        )
+
+        assert len(all_configs_after_promote) == 4
+
+        versions = [config.version for config in all_configs_after_promote]
+        assert versions == sorted(versions, reverse=True), (
+            "Configs should be sorted by version descending"
+        )
+
+        active_configs = [
+            config for config in all_configs_after_promote if config.active
+        ]
+        assert len(active_configs) == 1
+        assert active_configs[0].id == config_to_promote_id
+
+    async def test_promote_multiple_configs_only_one_active_rule(
+        self, session: AsyncSession, rule_definition: Rule
+    ):
+        """Test that when multiple rule configs exist, only the promoted one is active."""
+        ObjectRegistry.get_instance().register(rule_definition)
+
+        config_ids = []
+        for i in range(3):
+            rule_config = RuleEngineConfig(jdm=create_jdm_graph(rule_definition))
+            cfg = await rule_configuration.write_config(
+                rule_definition.name, rule_config
+            )
+            config_ids.append(cfg.id)
+
+        # Config_ids are in order of creation: [id_v1, id_v2, id_v3]
+        # After all writes, read_configs would return them ordered [v3, v2, v1]
+        # Let's promote the middle one created (which would be version 2)
+        # To get its ID robustly, let's re-fetch and pick based on version or order.
+        all_cfgs = await rule_configuration._read_configs(rule_definition.name)
+
+        # all_cfgs.configs is sorted by version desc (e.g. [v3, v2, v1])
+        # We want to promote the one with original version 2. This is all_cfgs.configs[1]
+        id_to_promote = all_cfgs[1].id
+
+        await rule_configuration.promote_config(id_to_promote)
+
+        configs = await rule_configuration.read_configs_with_default(
+            rule_definition.name, rule_definition.to_config()
+        )
+
+        assert len(configs) == 4
+        active_found = [c for c in configs if c.active]
+        assert len(active_found) == 1
+        assert active_found[0].id == id_to_promote
+
+        # Verify in database: iterate through all initially created config IDs
+        # and check their active status. Only id_to_promote should be active.
+        # config_ids was populated in order of creation: [id_for_v1, id_for_v2, id_for_v3]
+        # id_to_promote corresponds to the one with version 2 (the second one created).
+        for created_id in config_ids:
+            db_config = (
+                await session.exec(
+                    select(ObjectConfiguration).where(
+                        ObjectConfiguration.id == created_id
+                    )
+                )
+            ).first()
+            assert db_config is not None, f"Config with ID {created_id} not found in DB"
+            if created_id == id_to_promote:
+                assert db_config.active is True, (
+                    f"Promoted config {created_id} should be active"
+                )
+            else:
+                assert db_config.active is False, (
+                    f"Non-promoted config {created_id} should be inactive"
+                )

planar/test_object_registry.py

@@ -0,0 +1,14 @@
+from planar.registry_items import create_pydantic_model_for_workflow
+from planar.workflows.decorators import workflow
+
+
+@workflow()
+async def sample_workflow(foo: int, bar: str = "baz"):
+    pass
+
+
+def test_create_pydantic_model_for_workflow_strips_module_name():
+    model_cls = create_pydantic_model_for_workflow(sample_workflow)
+    assert model_cls.__name__ == "SampleWorkflowStartRequest"
+    assert "foo" in model_cls.model_fields
+    assert "bar" in model_cls.model_fields

planar/test_sqlalchemy.py

@@ -0,0 +1,158 @@
+from uuid import uuid4
+
+import pytest
+from sqlalchemy.exc import DBAPIError
+from sqlalchemy.ext.asyncio import AsyncEngine
+from sqlmodel import col, insert, select
+
+from planar.db import PlanarSession, new_session
+from planar.modeling.orm.planar_base_entity import PlanarBaseEntity
+
+
+class SomeModel(PlanarBaseEntity, table=True):
+    name: str
+    value: int = 0
+
+
+async def test_run_transaction_success(tmp_db_engine):
+    uuid = uuid4()
+    uuid2 = uuid4()
+
+    async def transaction_func(session: PlanarSession):
+        await session.exec(
+            insert(SomeModel).values(id=uuid, name="test_item", value=42)  # type: ignore
+        )
+        await session.exec(
+            insert(SomeModel).values(id=uuid2, name="test_item2", value=42)  # type: ignore
+        )
+
+    async with new_session(tmp_db_engine) as session:
+        session.max_conflict_retries = 3
+        await session.run_transaction(transaction_func, session)
+
+    async with new_session(tmp_db_engine) as session:
+        items = (
+            await session.exec(select(SomeModel).order_by(col(SomeModel.name)))
+        ).all()
+        assert items == [
+            SomeModel(id=uuid, name="test_item", value=42),
+            SomeModel(id=uuid2, name="test_item2", value=42),
+        ]
+
+
+async def test_run_transaction_failure(tmp_db_engine):
+    async def transaction_func(session: PlanarSession):
+        await session.exec(insert(SomeModel).values(name="test_item", value=42))  # type: ignore
+        raise ValueError("Test error")
+        await session.exec(insert(SomeModel).values(name="test_item2", value=42))  # type: ignore
+
+    async with new_session(tmp_db_engine) as session:
+        with pytest.raises(ValueError, match="Test error"):
+            session.max_conflict_retries = 3
+            await session.run_transaction(transaction_func, session)
+
+    async with new_session(tmp_db_engine) as session:
+        items = (await session.exec(select(SomeModel))).all()
+        assert items == []
+
+
+async def test_run_transaction_concurrent_retry_success(tmp_db_engine):
+    attempts = 0
+    uuid = uuid4()
+    uuid2 = uuid4()
+
+    async def transaction_func(session: PlanarSession):
+        nonlocal attempts
+        await session.exec(
+            insert(SomeModel).values(id=uuid, name="test_item", value=42)  # type: ignore
+        )
+        if attempts == 0:
+            attempts += 1
+            raise DBAPIError(
+                "Test error", None, Exception("could not serialize access")
+            )
+        await session.exec(
+            insert(SomeModel).values(id=uuid2, name="test_item2", value=42)  # type: ignore
+        )
+
+    async with new_session(tmp_db_engine) as session:
+        session.max_conflict_retries = 1
+        await session.run_transaction(transaction_func, session)
+
+    async with new_session(tmp_db_engine) as session:
+        items = (
+            await session.exec(select(SomeModel).order_by(col(SomeModel.name)))
+        ).all()
+        assert items == [
+            SomeModel(id=uuid, name="test_item", value=42),
+            SomeModel(id=uuid2, name="test_item2", value=42),
+        ]
+
+
+async def test_run_transaction_concurrent_retry_failure(tmp_db_engine):
+    attempts = 0
+
+    async def transaction_func(session: PlanarSession):
+        nonlocal attempts
+        await session.exec(insert(SomeModel).values(name="test_item", value=42))  # type: ignore
+        if attempts < 2:
+            attempts += 1
+            raise DBAPIError(
+                "Test error", None, Exception("could not serialize access")
+            )
+        await session.exec(insert(SomeModel).values(name="test_item2", value=42))  # type: ignore
+
+    async with new_session(tmp_db_engine) as session:
+        with pytest.raises(DBAPIError, match="Test error"):
+            session.max_conflict_retries = 1
+            await session.run_transaction(transaction_func, session)
+
+    async with new_session(tmp_db_engine) as session:
+        items = (await session.exec(select(SomeModel))).all()
+        assert items == []
+
+
+async def test_serializable_transaction_failure_1(tmp_db_engine: AsyncEngine):
+    if tmp_db_engine.dialect.name != "postgresql":
+        return pytest.skip("Test requires PostgreSQL database")
+
+    async with new_session(tmp_db_engine) as setup_session:
+        # Setup: Insert initial data
+        async with setup_session.begin():
+            setup_session.add(SomeModel(id=uuid4(), name="initial", value=10))
+
+    # Create two sessions
+    async with (
+        new_session(tmp_db_engine) as session1,
+        new_session(tmp_db_engine) as session2,
+    ):
+        # Begin transactions in both sessions
+        await session1.begin()
+        await session2.begin()
+
+        # Set serializable isolation level
+        await session1.set_serializable_isolation()
+        await session2.set_serializable_isolation()
+
+        # Session 1: Read data
+        item1 = (
+            await session1.exec(select(SomeModel).where(SomeModel.name == "initial"))
+        ).one()
+        assert item1.value == 10
+
+        # Session 2: Read the same data
+        item2 = (
+            await session2.exec(select(SomeModel).where(SomeModel.name == "initial"))
+        ).one()
+        assert item2.value == 10
+
+        # Both sessions update the same row
+        item1.value += 5
+        item2.value += 3
+
+        # Session 1: Commit should succeed
+        await session1.commit()
+
+        # Session 2: Commit should fail with serialization error
+        with pytest.raises(DBAPIError, match="could not serialize access"):
+            await session2.commit()