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

planar/logging/test_formatter.py

@@ -1,327 +0,0 @@
-import json
-import logging
-import re
-from datetime import datetime
-from decimal import Decimal
-from uuid import UUID, uuid4
-
-from pydantic import BaseModel
-
-from planar.logging.formatter import StructuredFormatter, dictionary_print, json_print
-
-
-class SampleModel(BaseModel):
-    name: str
-    value: int
-
-
-class TestJsonPrint:
-    def test_json_print_simple_values(self):
-        """Test json_print with simple values"""
-        assert json_print("test") == '"test"'
-        assert json_print(42) == "42"
-        assert json_print(True) == "true"
-        assert json_print(None) == "null"
-
-    def test_json_print_dict(self):
-        """Test json_print with dictionary"""
-        data = {"key": "value", "number": 42}
-        result = json_print(data)
-        assert json.loads(result) == data
-
-    def test_json_print_list_without_colors(self):
-        """Test json_print with list without colors - should produce valid JSON"""
-        data = ["item1", "item2", {"nested": "value"}]
-        result = json_print(data, use_colors=False)
-        # Should be valid JSON
-        parsed = json.loads(result)
-        assert parsed == data
-
-    def test_json_print_list_with_colors(self):
-        """Test json_print with list with colors - should produce valid JSON with ANSI codes"""
-        data = ["item1", "item2", {"nested": "value"}]
-        result = json_print(data, use_colors=True)
-        # Should contain ANSI escape codes but when stripped should be valid JSON
-        # Remove ANSI codes to check JSON validity
-        import re
-
-        ansi_escape = re.compile(r"\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])")
-        clean_result = ansi_escape.sub("", result)
-        parsed = json.loads(clean_result)
-        assert parsed == data
-        # Should contain color codes
-        assert "\x1b[" in result
-
-    def test_json_print_nested_structures(self):
-        """Test json_print with deeply nested structures"""
-        data = {
-            "messages": [
-                {"content": "hello", "role": "user"},
-                {"content": "world", "role": "assistant"},
-            ],
-            "tools": [
-                {"name": "tool1", "params": {"key": "value"}},
-                {"name": "tool2", "params": {"num": 42}},
-            ],
-        }
-        result = json_print(data, use_colors=False)
-        parsed = json.loads(result)
-        assert parsed == data
-
-    def test_json_print_pydantic_model(self):
-        """Test json_print with Pydantic models"""
-        model = SampleModel(name="test", value=42)
-        result = json_print(model, use_colors=False)
-        parsed = json.loads(result)
-        assert parsed == {"name": "test", "value": 42}
-
-    def test_json_print_custom_objects(self):
-        """Test json_print with custom objects that need string conversion"""
-
-        class CustomObject:
-            def __str__(self):
-                return "custom_object"
-
-        data = {"obj": CustomObject()}
-        result = json_print(data, use_colors=False)
-        parsed = json.loads(result)
-        assert parsed == {"obj": "custom_object"}
-
-    def test_json_print_no_ansi_in_escaped_strings(self):
-        """Test that ANSI codes don't get escaped in JSON strings"""
-        data = ["message1", "message2", {"key": "value"}]
-        result = json_print(data, use_colors=False)
-        # Should not contain escaped ANSI codes like \u001b
-        assert "\\u001b" not in result
-        # Should be valid JSON
-        parsed = json.loads(result)
-        assert parsed == data
-
-    def test_json_print_complex_types(self):
-        """Test json_print with datetime, uuid, and decimal types"""
-        test_datetime = datetime(2023, 12, 25, 10, 30, 45)
-        test_uuid = uuid4()
-        test_decimal = Decimal("123.45")
-
-        # Test complex data structure with these types
-        data = {
-            "timestamp": test_datetime,
-            "id": test_uuid,
-            "amount": test_decimal,
-            "nested": {
-                "dates": [test_datetime, datetime(2024, 1, 1)],
-                "ids": [test_uuid, uuid4()],
-                "values": [test_decimal, Decimal("67.89")],
-            },
-        }
-
-        # Test without colors
-        result = json_print(data, use_colors=False)
-
-        # Should be valid JSON
-        parsed = json.loads(result)
-
-        # All complex types should be converted to strings
-        assert isinstance(parsed["timestamp"], str)
-        assert isinstance(parsed["id"], str)
-        assert isinstance(parsed["amount"], str)
-        assert isinstance(parsed["nested"]["dates"][0], str)
-        assert isinstance(parsed["nested"]["ids"][0], str)
-        assert isinstance(parsed["nested"]["values"][0], str)
-
-        # Verify string representations contain expected content
-        assert "2023-12-25" in parsed["timestamp"]
-        assert str(test_uuid) == parsed["id"]
-        assert "123.45" in parsed["amount"]
-
-        # Test with colors - should also work and produce valid JSON when stripped
-        result_colored = json_print(data, use_colors=True)
-        assert "\x1b[" in result_colored  # Should contain ANSI codes
-
-        ansi_escape = re.compile(r"\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])")
-        clean_result = ansi_escape.sub("", result_colored)
-        parsed_colored = json.loads(clean_result)
-        assert parsed_colored == parsed  # Should be same as non-colored version
-
-    def test_json_print_with_base_model(self):
-        """Test json_print with BaseModel using complex data"""
-
-        class TestModel(BaseModel):
-            name: str
-            date: datetime
-            uuid_val: UUID
-            decimal_val: Decimal
-
-        model = TestModel(
-            name="test",
-            date=datetime(2023, 12, 25, 10, 30, 45),
-            uuid_val=uuid4(),
-            decimal_val=Decimal("123.45"),
-        )
-        result = json_print(model, use_colors=False)
-        parsed = json.loads(result)
-        assert parsed == {
-            "name": "test",
-            "date": "2023-12-25T10:30:45",
-            "uuid_val": str(model.uuid_val),
-            "decimal_val": "123.45",
-        }
-
-
-class TestDictionaryPrint:
-    def test_dictionary_print_simple(self):
-        """Test dictionary_print with simple values"""
-        data = {"key": "value", "number": 42}
-        result = dictionary_print(data, use_colors=False)
-        assert 'key="value"' in result
-        assert "number=42" in result
-
-    def test_dictionary_print_with_lists(self):
-        """Test dictionary_print with lists"""
-        data = {"items": ["a", "b", "c"], "count": 3}
-        result = dictionary_print(data, use_colors=False)
-        assert 'items=["a","b","c"]' in result or 'items=["a", "b", "c"]' in result
-        assert "count=3" in result
-
-    def test_dictionary_print_with_colors(self):
-        """Test dictionary_print with colors enabled"""
-        data = {"key": "value"}
-        result = dictionary_print(data, use_colors=True)
-        # Should contain ANSI codes
-        assert "\x1b[" in result
-        # Should still contain the key-value pair
-        assert "key=" in result
-
-
-class TestStructuredFormatter:
-    def test_structured_formatter_with_extra_attrs(self):
-        """Test StructuredFormatter with extra attributes"""
-        formatter = StructuredFormatter(use_colors=False)
-
-        record = logging.LogRecord(
-            name="test.logger",
-            level=logging.INFO,
-            pathname="test.py",
-            lineno=1,
-            msg="test message",
-            args=(),
-            exc_info=None,
-        )
-
-        # Add extra attributes (simulating what PlanarLogger does)
-        record.__dict__.update(
-            {
-                "$workflow_id": "test-workflow",
-                "$step_id": 42,
-                "$messages": ["msg1", "msg2"],
-            }
-        )
-
-        result = formatter.format(record)
-        assert "workflow_id=" in result
-        assert "step_id=42" in result
-        assert "messages=" in result
-        # Should not contain escaped ANSI codes
-        assert "\\u001b" not in result
-
-    def test_structured_formatter_with_colors(self):
-        """Test StructuredFormatter with colors enabled"""
-        formatter = StructuredFormatter(use_colors=True)
-
-        record = logging.LogRecord(
-            name="test.logger",
-            level=logging.INFO,
-            pathname="test.py",
-            lineno=1,
-            msg="test message",
-            args=(),
-            exc_info=None,
-        )
-
-        result = formatter.format(record)
-        # Should contain ANSI color codes
-        assert "\x1b[" in result
-
-    def test_structured_formatter_complex_data(self):
-        """Test StructuredFormatter with complex nested data like the original issue"""
-        formatter = StructuredFormatter(use_colors=True)
-
-        record = logging.LogRecord(
-            name="planar.ai.test_agent",
-            level=logging.INFO,
-            pathname="test_agent.py",
-            lineno=188,
-            msg="patched_complete",
-            args=(),
-            exc_info=None,
-        )
-
-        # Simulate the complex data from the original issue
-        record.__dict__.update(
-            {
-                "$messages": [
-                    {"content": "Use tools to solve the problem"},
-                    {"content": "Problem: complex problem", "files": []},
-                    {
-                        "content": None,
-                        "tool_calls": [
-                            {
-                                "id": "call_1",
-                                "name": "tool1",
-                                "arguments": {"param": "test_param"},
-                            }
-                        ],
-                    },
-                    {"content": "Tool 1 result: test_param", "tool_call_id": "call_1"},
-                ],
-                "$tools": [
-                    {
-                        "name": "tool1",
-                        "description": "Test tool 1",
-                        "parameters": {
-                            "type": "object",
-                            "properties": {"param": {"type": "string"}},
-                        },
-                    },
-                    {
-                        "name": "tool2",
-                        "description": "Test tool 2",
-                        "parameters": {
-                            "type": "object",
-                            "properties": {"num": {"type": "integer"}},
-                        },
-                    },
-                ],
-                "$workflow_id": "test-workflow-id",
-                "$step_id": 4,
-            }
-        )
-
-        result = formatter.format(record)
-
-        # Should contain the message
-        assert "patched_complete" in result
-        assert "planar.ai.test_agent" in result
-
-        # Should contain the extra attributes
-        assert "messages=" in result
-        assert "tools=" in result
-        assert "workflow_id=" in result
-        assert "step_id=" in result
-
-        # Most importantly: should NOT contain escaped ANSI codes
-        assert "\\u001b" not in result
-
-        # Should contain actual ANSI codes (for colors)
-        assert "\x1b[" in result
-
-        # Verify the fix - the data should be properly formatted JSON with colors
-        # Extract the JSON parts and verify they're valid when ANSI codes are stripped
-        import re
-
-        ansi_escape = re.compile(r"\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])")
-        clean_result = ansi_escape.sub("", result)
-
-        # The messages should be valid JSON when extracted
-        assert '"content": "Use tools to solve the problem"' in clean_result
-        assert '"content": "Problem: complex problem"' in clean_result

planar/modeling/mixins/test_auditable.py

@@ -1,97 +0,0 @@
-import pytest
-from sqlmodel import Field, SQLModel
-
-from planar.db import PlanarSession, new_session
-from planar.modeling.mixins.auditable import AuditableMixin
-from planar.security.auth_context import (
-    Principal,
-    as_principal,
-    get_current_principal,
-)
-
-TEST_PRINCIPAL = Principal(
-    sub="test_user",
-    iss="test",
-    exp=1000,
-    iat=1000,
-    sid="test",
-    jti="test",
-    org_id="test",
-    org_name="test",
-    user_first_name="test",
-    user_last_name="test",
-    user_email="test@test.com",
-    role="test",
-    permissions=["test"],
-    extra_claims={"test": "test"},
-)
-
-
-class TestAuditableModel(AuditableMixin, SQLModel, table=True):
-    """Test model using AuditableMixin."""
-
-    __test__ = False
-
-    id: int | None = Field(default=None, primary_key=True)
-    name: str = Field()
-
-
-@pytest.fixture
-async def session(tmp_db_engine):
-    """Create a database session."""
-
-    async with new_session(tmp_db_engine) as session:
-        await (await session.connection()).run_sync(SQLModel.metadata.create_all)
-        yield session
-
-
-def test_auditable_mixin_has_audit_fields():
-    """Test that AuditableMixin provides default audit fields."""
-    model = TestAuditableModel(name="test")
-
-    assert hasattr(model, "created_by")
-    assert hasattr(model, "updated_by")
-    assert model.created_by == "system"
-    assert model.updated_by == "system"
-
-
-async def test_auditable_mixin_sets_values_on_insert(session: PlanarSession):
-    """Test that audit fields are set from SecurityContext on insert."""
-    with as_principal(TEST_PRINCIPAL):
-        model = TestAuditableModel(name="test_insert")
-        session.add(model)
-        await session.commit()
-
-        # Refresh to get the updated values
-        await session.refresh(model)
-
-        assert model.created_by == "test@test.com"
-        assert model.updated_by == "test@test.com"
-
-
-async def test_auditable_mixin_sets_updated_by_on_update(session: PlanarSession):
-    """Test that updated_by is set from SecurityContext on update."""
-    # First insert with initial user
-    with as_principal(TEST_PRINCIPAL):
-        model = TestAuditableModel(name="test_update")
-        session.add(model)
-        await session.commit()
-        await session.refresh(model)
-
-        assert model.created_by == "test@test.com"
-        assert model.updated_by == "test@test.com"
-
-    # Now update with different user
-    updating_principal = TEST_PRINCIPAL.model_copy(
-        update={"user_email": "updating@test.com"}
-    )
-    with as_principal(updating_principal):
-        assert get_current_principal() == updating_principal
-        model.name = "updated_name"
-        session.add(model)
-        await session.commit()
-        await session.refresh(model)
-
-        # created_by should remain the same, updated_by should change
-        assert model.created_by == "test@test.com"
-        assert model.updated_by == "updating@test.com"

planar/modeling/mixins/test_timestamp.py

@@ -1,134 +0,0 @@
-import asyncio
-from datetime import timedelta
-
-from sqlalchemy.ext.asyncio import AsyncEngine
-from sqlmodel import select
-
-from planar.db import new_session
-from planar.modeling.mixins import TimestampMixin
-from planar.modeling.orm.planar_base_entity import PlanarBaseEntity
-from planar.utils import utc_now
-
-
-class TimestampTestModel(TimestampMixin, PlanarBaseEntity, table=True):
-    """Test model that uses the TimestampMixin."""
-
-    name: str
-    value: int = 0
-
-
-async def test_timestamp_fields_set_on_creation(tmp_db_engine: AsyncEngine):
-    """Test that created_at and updated_at are set when a model is created."""
-    # Record time before the operation
-    before_creation = utc_now()
-
-    # Create and insert model
-    model_id = None
-    async with new_session(tmp_db_engine) as session:
-        model = TimestampTestModel(name="test_item", value=42)
-        session.add(model)
-        await session.commit()
-        model_id = model.id
-
-    # Record time after the operation
-    after_creation = utc_now()
-
-    # Fetch model to verify timestamps
-    async with new_session(tmp_db_engine) as session:
-        created_model = (
-            await session.exec(
-                select(TimestampTestModel).where(TimestampTestModel.id == model_id)
-            )
-        ).one()
-
-    # Verify created_at is set and within the expected time range
-    # and that it equals updated_at
-    assert created_model.created_at is not None
-    assert before_creation <= created_model.created_at <= after_creation
-    assert created_model.created_at == created_model.updated_at
-
-
-async def test_updated_at_reflects_changes(tmp_db_engine: AsyncEngine):
-    """Test that updated_at is updated when a model is modified."""
-    # Create and insert model
-    model_id = None
-    async with new_session(tmp_db_engine) as session:
-        model = TimestampTestModel(name="test_item", value=42)
-        session.add(model)
-        await session.commit()
-        model_id = model.id
-
-        # Get initial created_at and updated_at values
-        initial_model = (
-            await session.exec(
-                select(TimestampTestModel).where(TimestampTestModel.id == model_id)
-            )
-        ).one()
-        await session.commit()
-        initial_created_at = initial_model.created_at
-        initial_updated_at = initial_model.updated_at
-
-    # Wait a moment to ensure timestamp will be different
-    await asyncio.sleep(0.01)
-
-    # Record time before update
-    before_update = utc_now()
-
-    # Update the model
-    async with new_session(tmp_db_engine) as session:
-        model_to_update = (
-            await session.exec(
-                select(TimestampTestModel).where(TimestampTestModel.id == model_id)
-            )
-        ).one()
-        model_to_update.value = 99
-        await session.commit()
-
-    # Record time after update
-    after_update = utc_now()
-
-    # Verify the timestamps
-    async with new_session(tmp_db_engine) as session:
-        updated_model = (
-            await session.exec(
-                select(TimestampTestModel).where(TimestampTestModel.id == model_id)
-            )
-        ).one()
-        await session.commit()
-
-        # created_at should not change
-        assert updated_model.created_at == initial_created_at
-
-        # updated_at should be newer than before
-        assert updated_model.updated_at is not None
-        assert initial_updated_at is not None
-        assert updated_model.updated_at > initial_updated_at
-        assert before_update <= updated_model.updated_at <= after_update
-
-
-async def test_timestamp_init_with_explicit_values():
-    """Test initializing a model with explicit timestamp values."""
-    # Create a specific timestamp
-    now = utc_now()
-    past = now - timedelta(days=1)
-
-    # Initialize model with explicit timestamps
-    model = TimestampTestModel(
-        name="test_explicit_timestamps",
-        value=200,
-        created_at=past,
-        updated_at=now,
-    )
-
-    # Verify timestamps match what we provided
-    assert model.created_at == past
-    assert model.updated_at == now
-
-    # Initialize model with only created_at
-    model2 = TimestampTestModel(
-        name="test_partial_timestamps", value=300, created_at=past
-    )
-
-    # Verify updated_at equals created_at when only created_at is provided
-    assert model2.created_at == past
-    assert model2.updated_at == past

planar/modeling/mixins/test_uuid_primary_key.py

@@ -1,52 +0,0 @@
-from uuid import UUID
-
-from sqlmodel import Field
-
-from planar.db import PlanarSession
-from planar.modeling.mixins.uuid_primary_key import UUIDPrimaryKeyMixin
-from planar.modeling.orm.planar_base_entity import PlanarBaseEntity
-
-
-class UUIDModelTest(PlanarBaseEntity, UUIDPrimaryKeyMixin, table=True):
-    """Test model using UUIDPrimaryKeyMixin."""
-
-    name: str = Field()
-
-
-def test_uuid_primary_key_mixin_creates_uuid_id():
-    """Test that UUIDPrimaryKeyMixin provides a UUID id field."""
-    model = UUIDModelTest(name="test")
-
-    assert hasattr(model, "id")
-    assert isinstance(model.id, UUID)
-    assert model.id is not None
-
-
-def test_uuid_primary_key_mixin_allows_custom_id():
-    """Test that a custom UUID can be provided."""
-    custom_uuid = UUID("12345678-1234-5678-1234-123456789abc")
-    model = UUIDModelTest(id=custom_uuid, name="test")
-
-    assert model.id == custom_uuid
-
-
-async def test_uuid_primary_key_mixin_is_primary_key(session: PlanarSession):
-    """Test that the id field works as a primary key."""
-    model1 = UUIDModelTest(name="test1")
-    model2 = UUIDModelTest(name="test2")
-
-    session.add(model1)
-    session.add(model2)
-    await session.commit()
-
-    # Both should have different IDs
-    assert model1.id != model2.id
-
-    # Both should be retrievable by their IDs
-    retrieved1 = await session.get(UUIDModelTest, model1.id)
-    retrieved2 = await session.get(UUIDModelTest, model2.id)
-
-    assert retrieved1 is not None
-    assert retrieved1.name == "test1"
-    assert retrieved2 is not None
-    assert retrieved2.name == "test2"