planar 0.9.0__py3-none-any.whl → 0.9.1__py3-none-any.whl

planar/_version.py

@@ -1 +1 @@
-VERSION = "0.9.0"
+VERSION = "0.9.1"

planar/app.py

@@ -80,7 +80,10 @@ class PlanarApp:
         )
         self.policy_service: PolicyService | None = None
 
-        self.db_manager = DatabaseManager(db_url=self.config.connection_url())
+        self.db_manager = DatabaseManager(
+            db_url=self.config.connection_url(),
+            entity_schema=self.config.app.entity_schema,
+        )
 
         if self.config.storage:
             self.storage = create_from_config(self.config.storage)
@@ -220,9 +223,7 @@ class PlanarApp:
 
         # Begin the normal lifespan logic
         self.db_manager.connect()
-        await self.db_manager.migrate(
-            self.config.use_alembic if self.config.use_alembic is not None else True
-        )
+        await self.db_manager.migrate()
 
         self.orchestrator = WorkflowOrchestrator(self.db_manager.get_engine())
         config_tok = config_var.set(self.config)

planar/config.py

@@ -127,6 +127,10 @@ DatabaseConfig = Annotated[
 class AppConfig(BaseModel):
     db_connection: str
     max_db_conflict_retries: int | None = None
+    # Default schema for user-defined entities (PlanarBaseEntity)
+    # Postgres: used as the target schema for user tables
+    # SQLite: ignored (SQLite has no schemas)
+    entity_schema: str = "planar_entity"
 
 
 def default_storage_config() -> StorageConfig:
@@ -224,7 +228,6 @@ class PlanarConfig(BaseModel):
     environment: Environment = Environment.DEV
     security: SecurityConfig = SecurityConfig()
     logging: dict[str, LoggerConfig] | None = None
-    use_alembic: bool | None = True
     otel: OtelConfig | None = None
     data: DataConfig | None = None
 

planar/data/dataset.py

@@ -212,8 +212,21 @@ class PlanarDataset(BaseModel):
         else:
             raise ValueError(f"Unsupported catalog type: {catalog_config.type}")
 
+        try:
+            await asyncio.to_thread(con.raw_sql, "INSTALL ducklake")
+            match catalog_config.type:
+                case "sqlite":
+                    await asyncio.to_thread(con.raw_sql, "INSTALL sqlite;")
+                case "postgres":
+                    await asyncio.to_thread(con.raw_sql, "INSTALL postgres;")
+            logger.debug(
+                "installed Ducklake extensions", catalog_type=catalog_config.type
+            )
+        except Exception as e:
+            raise DataError(f"Failed to install Ducklake extensions: {e}") from e
+
         # Build ATTACH statement
-        attach_sql = f"ATTACH 'ducklake:{metadata_path}'"
+        attach_sql = f"ATTACH 'ducklake:{metadata_path}' AS planar_ducklake"
 
         # Add data path from storage config
         storage = data_config.storage
@@ -227,7 +240,11 @@ class PlanarDataset(BaseModel):
                 storage, "directory", "."
             )
 
-        attach_sql += f" (DATA_PATH '{data_path}')"
+        ducklake_catalog = data_config.catalog_name
+        attach_sql += f" (DATA_PATH '{data_path}'"
+        if catalog_config.type != "sqlite":
+            attach_sql += f", METADATA_SCHEMA '{ducklake_catalog}'"
+        attach_sql += ");"
 
         # Attach to Ducklake
         try:
@@ -235,38 +252,12 @@ class PlanarDataset(BaseModel):
         except Exception as e:
             raise DataError(f"Failed to attach to Ducklake: {e}") from e
 
-        # Check available catalogs (what ibis calls schemas) and use the correct one
-        try:
-            catalogs = await asyncio.to_thread(con.list_catalogs)
-            logger.debug("available catalogs", catalogs=catalogs)
-
-            # Find the ducklake catalog (it might have a different name pattern)
-            ducklake_catalog = None
-            for cat in catalogs:
-                if "ducklake" in cat.lower() or cat == data_config.catalog_name:
-                    ducklake_catalog = cat
-                    break
-
-            if ducklake_catalog:
-                if not ducklake_catalog.replace("_", "").replace("-", "").isalnum():
-                    raise DataError(f"Invalid catalog name format: {ducklake_catalog}")
-                await asyncio.to_thread(con.raw_sql, f"USE {ducklake_catalog}")
-                logger.debug("using catalog", catalog=ducklake_catalog)
-            else:
-                catalog_name = data_config.catalog_name
-                if not catalog_name.replace("_", "").replace("-", "").isalnum():
-                    raise DataError(f"Invalid catalog name format: {catalog_name}")
-                await asyncio.to_thread(
-                    con.raw_sql,
-                    f"CREATE SCHEMA IF NOT EXISTS {catalog_name}",
-                )
-                await asyncio.to_thread(con.raw_sql, f"USE {catalog_name}")
-                logger.debug(
-                    "created and using catalog", catalog=data_config.catalog_name
-                )
-
-        except Exception as e:
-            logger.warning("failed to set catalog, using default", error=str(e))
-            # Continue without setting catalog - will use qualified names
+        await asyncio.to_thread(con.raw_sql, "USE planar_ducklake;")
+        logger.debug(
+            "connection created",
+            catalog=ducklake_catalog,
+            catalog_type=catalog_config.type,
+            attach_sql=attach_sql,
+        )
 
         return con

planar/db/db.py

@@ -20,7 +20,10 @@ from sqlmodel.ext.asyncio.session import AsyncSession
 
 import planar
 from planar.logging import get_logger
-from planar.modeling.orm.planar_base_entity import PLANAR_APPLICATION_METADATA
+from planar.modeling.orm.planar_base_entity import (
+    PLANAR_APPLICATION_METADATA,
+    PLANAR_ENTITY_SCHEMA,
+)
 from planar.utils import P, R, T, U, exponential_backoff_with_jitter
 
 
@@ -170,9 +173,12 @@ class DatabaseManager:
     def __init__(
         self,
         db_url: str | URL,
+        *,
+        entity_schema: str = PLANAR_ENTITY_SCHEMA,
     ):
         self.db_url = make_url(db_url) if isinstance(db_url, str) else db_url
         self.engine: AsyncEngine | None = None
+        self.entity_schema = entity_schema
 
     def _create_sqlite_engine(self, url: URL) -> AsyncEngine:
         # in practice this high timeout is only use
@@ -189,9 +195,14 @@ class DatabaseManager:
                 # even though it is the default value.
                 autocommit=LEGACY_TRANSACTION_CONTROL,
             ),
-            # SQLite doesn't support schemas, so we need to translate the planar schema
-            # name to None.
-            execution_options={"schema_translate_map": {"planar": None}},
+            # SQLite doesn't support schemas, so we need to translate the planar and user
+            # schema names to None.
+            execution_options={
+                "schema_translate_map": {
+                    "planar": None,
+                    PLANAR_ENTITY_SCHEMA: None,
+                }
+            },
         )
 
         def do_begin(conn: Connection):
@@ -202,7 +213,12 @@ class DatabaseManager:
         return engine
 
     def _create_postgresql_engine(self, url: URL) -> AsyncEngine:
-        engine = create_async_engine(url)
+        # Map default (PLANAR_ENTITY_SCHEMA) schema to the configured entity schema for user tables.
+        # Leave the system table schema ('planar') unmapped so system tables are not overridden.
+        schema_map = {PLANAR_ENTITY_SCHEMA: self.entity_schema}
+        engine = create_async_engine(
+            url, execution_options={"schema_translate_map": schema_map}
+        )
 
         return engine
 
@@ -214,6 +230,12 @@ class DatabaseManager:
 
         db_backend = self.db_url.get_backend_name()
 
+        if self.entity_schema == PLANAR_SCHEMA:
+            logger.warning(
+                "entity_schema is set to 'planar'; mixing user and system tables in the same schema is discouraged",
+                entity_schema=self.entity_schema,
+            )
+
         match db_backend:
             case "sqlite":
                 logger.info(
@@ -293,27 +315,23 @@ class DatabaseManager:
             else:
                 # Ensure planar schema exists
                 await conn.execute(text(f"CREATE SCHEMA IF NOT EXISTS {PLANAR_SCHEMA}"))
+                # Ensure the configured entity schema exists
+                if self.entity_schema != PLANAR_SCHEMA:
+                    await conn.execute(
+                        text(f"CREATE SCHEMA IF NOT EXISTS {self.entity_schema}")
+                    )
 
-    async def migrate(self, use_alembic: bool):
+    async def migrate(self):
         """
         Runs database migrations.
         By default, uses SQLModel.metadata.create_all.
-        Set use_alembic=True to use Alembic (requires Alembic setup).
         """
         if not self.engine:
             raise RuntimeError("Database engine not initialized. Call connect() first.")
 
-        logger.info("starting database migration")
-        if use_alembic:
-            logger.info("using alembic for migrations")
-            await self._setup_database()
-            await self._run_system_migrations()
-            # For now user migrations are not supported, so we fall back to SQLModel.metadata.create_all
-            async with self.engine.begin() as conn:
-                await conn.run_sync(PLANAR_APPLICATION_METADATA.create_all)
-
-        else:
-            async with self.engine.begin() as conn:
-                await self._setup_database()
-                await conn.run_sync(PLANAR_FRAMEWORK_METADATA.create_all)
-                await conn.run_sync(PLANAR_APPLICATION_METADATA.create_all)
+        logger.info("starting database migration with alembic")
+        await self._setup_database()
+        await self._run_system_migrations()
+        # For now user migrations are not supported, so we fall back to SQLModel.metadata.create_all
+        async with self.engine.begin() as conn:
+            await conn.run_sync(PLANAR_APPLICATION_METADATA.create_all)

planar/files/test_files.py

@@ -19,15 +19,14 @@ from planar.workflows.decorators import workflow
 from planar.workflows.execution import execute
 from planar.workflows.models import Workflow
 
-app = PlanarApp(
-    config=sqlite_config(":memory:"),
-    title="Planar app for testing file workflows",
-    description="Testing",
-)
-
 
 @pytest.fixture(name="app")
-def app_fixture():
+def app_fixture(tmp_db_path: str):
+    app = PlanarApp(
+        config=sqlite_config(tmp_db_path),
+        title="Planar app for testing file workflows",
+        description="Testing",
+    )
     yield app
 
 

planar/modeling/mixins/test_auditable.py

@@ -37,10 +37,10 @@ class TestAuditableModel(AuditableMixin, SQLModel, table=True):
 
 
 @pytest.fixture
-async def session(mem_db_engine):
+async def session(tmp_db_engine):
     """Create a database session."""
 
-    async with new_session(mem_db_engine) as session:
+    async with new_session(tmp_db_engine) as session:
         await (await session.connection()).run_sync(SQLModel.metadata.create_all)
         yield session
 

planar/modeling/orm/planar_base_entity.py

@@ -12,7 +12,10 @@ from .reexports import SQLModel
 logger = get_logger("orm.PlanarBaseEntity")
 
 
-PLANAR_APPLICATION_METADATA = MetaData()
+# Default schema for all entity / user tables, but can be overridden by the user
+# in planar configuration, which db.py uses.
+PLANAR_ENTITY_SCHEMA = "planar_entity"
+PLANAR_APPLICATION_METADATA = MetaData(schema=PLANAR_ENTITY_SCHEMA)
 
 
 class PlanarBaseEntity(UUIDPrimaryKeyMixin, AuditableMixin, SQLModel, table=False):

planar/routers/test_agents_router.py

@@ -15,10 +15,10 @@ from planar.testing.planar_test_client import PlanarTestClient
 
 
 @pytest.fixture(name="app")
-def app_fixture():
+def app_fixture(tmp_db_path: str):
     """Create a test app with agents."""
     app = PlanarApp(
-        config=sqlite_config(":memory:"),
+        config=sqlite_config(tmp_db_path),
         title="Test app for agent router",
         description="Testing agent endpoints",
     )

planar/routers/test_files_router.py

@@ -10,9 +10,9 @@ from planar.testing.planar_test_client import PlanarTestClient
 
 
 @pytest.fixture(name="app")
-def app_fixture():
+def app_fixture(tmp_db_path: str):
     return PlanarApp(
-        config=sqlite_config(":memory:"),
+        config=sqlite_config(tmp_db_path),
         title="Test app for files router",
         description="Testing files endpoints",
     )

planar/routers/test_object_config_router.py

@@ -41,10 +41,10 @@ class OutputFromTestRule(BaseModel):
 
 
 @pytest.fixture(name="app")
-def app_fixture():
+def app_fixture(tmp_db_path: str):
     """Create a test app with agents and rules."""
     app = PlanarApp(
-        config=sqlite_config(":memory:"),
+        config=sqlite_config(tmp_db_path),
         title="Test app for object config router",
         description="Testing object configuration endpoints",
     )

planar/routers/test_rule_router.py

@@ -83,9 +83,9 @@ def pricing_rule_with_wrong_type(
 
 
 @pytest.fixture(name="app")
-def app_fixture():
+def app_fixture(tmp_db_path: str):
     app = PlanarApp(
-        config=sqlite_config(":memory:"),
+        config=sqlite_config(tmp_db_path),
         title="Test app for agent router",
         description="Testing agent endpoints",
     )

planar/routers/test_workflow_router.py

@@ -120,18 +120,16 @@ async def file_processing_workflow(file: PlanarFile):
     )
 
 
-app = PlanarApp(
-    config=sqlite_config("test_workflow_router.db"),
-    title="Test Workflow Router API",
-    description="API for testing workflow routers",
-)
-
-
 # ------ TESTS ------
 
 
 @pytest.fixture(name="app")
-def app_fixture():
+def app_fixture(tmp_db_path: str):
+    app = PlanarApp(
+        config=sqlite_config(tmp_db_path),
+        title="Test Workflow Router API",
+        description="API for testing workflow routers",
+    )
     # Re-register workflows since ObjectRegistry gets reset before each test
     app.register_workflow(expense_approval_workflow)
     app.register_workflow(file_processing_workflow)

planar/scaffold_templates/app/flows/process_invoice.py.j2

@@ -1,5 +1,4 @@
 from planar.ai import Agent
-from planar.ai.providers import OpenAI
 from planar.files import PlanarFile
 from planar.human import Human
 from planar.rules.decorator import rule
@@ -23,7 +22,7 @@ class RuleOutput(BaseModel):
 
 invoice_agent = Agent(
     name="Invoice Agent",
-    model=OpenAI.gpt_4_1,
+    model="openai:gpt-4.1",
     tools=[],
     max_turns=1,
     system_prompt="Extract vendor and amount from invoice text.",

planar/scaffold_templates/pyproject.toml.j2

@@ -3,8 +3,8 @@ name = "{{ name }}"
 version = "0.1.0"
 requires-python = ">=3.12"
 dependencies = [
-    "planar>=0.6.0",
+    "planar>=0.9.0",
 ]
 
 [[tool.uv.index]]
-url = "https://coplane.github.io/planar/simple/"
+url = "https://coplane.github.io/planar/simple/"

planar/test_sqlalchemy.py

@@ -3,7 +3,7 @@ from uuid import uuid4
 import pytest
 from sqlalchemy.exc import DBAPIError
 from sqlalchemy.ext.asyncio import AsyncEngine
-from sqlmodel import col, insert, select
+from sqlmodel import col, insert, select, text
 
 from planar.db import PlanarSession, new_session
 from planar.modeling.orm.planar_base_entity import PlanarBaseEntity
@@ -156,3 +156,38 @@ async def test_serializable_transaction_failure_1(tmp_db_engine: AsyncEngine):
         # Session 2: Commit should fail with serialization error
         with pytest.raises(DBAPIError, match="could not serialize access"):
             await session2.commit()
+
+
+async def test_entity_schema_and_planar_schema_presence(tmp_db_engine: AsyncEngine):
+    table_name = SomeModel.__tablename__
+
+    async with new_session(tmp_db_engine) as session:
+        dialect = session.dialect.name
+
+        if dialect == "postgresql":
+            # Verify schemas include 'planar' and the default entity schema 'planar_entity'
+            res = await session.exec(
+                text("select schema_name from information_schema.schemata")  # type: ignore[arg-type]
+            )
+            schemas = {row[0] for row in res}
+            assert "planar" in schemas
+            assert "planar_entity" in schemas
+
+            # Verify SomeModel table is created in the entity schema
+            res = await session.exec(
+                text(
+                    "select table_schema from information_schema.tables where table_name = :tn"
+                ).bindparams(tn=table_name)  # type: ignore[arg-type]
+            )
+            table_schemas = {row[0] for row in res}
+            assert "planar_entity" in table_schemas
+            assert "public" not in table_schemas
+
+        else:
+            # SQLite: no schemas; ensure table exists
+            res = await session.exec(
+                text("select name from sqlite_master where type='table'")  # type: ignore[arg-type]
+            )
+            tables = {row[0] for row in res}
+            assert table_name in tables
+            assert not any(name.startswith("planar.") for name in tables)

planar/testing/fixtures.py

@@ -254,23 +254,9 @@ async def tmp_db_engine(tmp_db_url: str):
         yield engine
 
 
-@pytest.fixture()
-async def mem_db_engine(tmp_db_engine):
-    # Memory databases don't work well with aiosqlite due to the "database
-    # table is locked" error (which doesn't respect timeouts), so just use a
-    # temporary db file for now until we figure out a fix.
-    yield tmp_db_engine
-
-    # name = uuid4()
-    # async with engine_context(
-    #     f"sqlite+aiosqlite:///file:{name}?mode=memory&cache=shared&uri=true"
-    # ) as engine:
-    #     yield engine
-
-
 @pytest.fixture(name="session")
-async def session_fixture(mem_db_engine):
-    async with new_session(mem_db_engine) as session:
+async def session_fixture(tmp_db_engine):
+    async with new_session(tmp_db_engine) as session:
         tok = session_var.set(session)
         yield session
         session_var.reset(tok)
@@ -318,7 +304,7 @@ async def tracer_fixture():
 async def engine_context(url: str):
     db_manager = DatabaseManager(url)
     db_manager.connect()
-    await db_manager.migrate(use_alembic=True)
+    await db_manager.migrate()
     engine = db_manager.get_engine()
     tok = engine_var.set(engine)
     yield engine

planar/workflows/test_lock_timeout.py

@@ -26,7 +26,7 @@ async def long_running_workflow():
     return "finished"
 
 
-async def test_lock_timer_extension(mem_db_engine):
+async def test_lock_timer_extension(tmp_db_engine):
     tracer = SynchronizableTracer()
     tracer_var.set(tracer)
     lock_acquired = tracer.instrument(
@@ -36,7 +36,7 @@ async def test_lock_timer_extension(mem_db_engine):
         TraceSpec(function_name="lock_heartbeat", message="commit")
     )
 
-    async with new_session(mem_db_engine) as session:
+    async with new_session(tmp_db_engine) as session:
         # This test verifies that when a workflow is executing, the heartbeat task
         # (lock_heartbeat) extends the workflow's lock_until field. We run a
         # long-running workflow (which sleeps for 1 second) with a short lock
@@ -95,7 +95,7 @@ async def crashed_worker_workflow():
     return "completed"
 
 
-async def test_orchestrator_resumes_crashed_worker(mem_db_engine):
+async def test_orchestrator_resumes_crashed_worker(tmp_db_engine):
     # This test simulates the scenario where a worker has “crashed” after
     # locking a workflow. We start a workflow that suspends. Then we add a LockedResource
     # record with an expired lock_until time to simulate a crashed
@@ -105,7 +105,7 @@ async def test_orchestrator_resumes_crashed_worker(mem_db_engine):
     # the workflow to be resumed. Finally, we verify that the workflow
     # completes successfully. Start the workflow – its first execution will
     # suspend.
-    async with new_session(mem_db_engine) as session:
+    async with new_session(tmp_db_engine) as session:
         session_var.set(session)
         wf = await crashed_worker_workflow.start()
 

{planar-0.9.0.dist-info → planar-0.9.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: planar
-Version: 0.9.0
+Version: 0.9.1
 Summary: Add your description here
 License-Expression: LicenseRef-Proprietary
 Requires-Python: >=3.12
@@ -61,8 +61,8 @@ The workflow system in Planar is a sophisticated orchestration framework that en
     - Concurrency Control: Uses a locking mechanism to prevent multiple executions
     - Recovery: Can recover from crashes by detecting stalled workflows
   3. Main Components:
-    - @workflow decorator: Marks a function as a workflow with persistence
-    - @step decorator: Wraps function calls inside a workflow to make them resumable
+    - `@workflow` decorator: Marks a function as a workflow with persistence
+    - `@step` decorator: Wraps function calls inside a workflow to make them resumable
     - Suspend class: Allows pausing workflow execution
     - workflow_orchestrator: Background task that finds and resumes suspended workflows
   4. REST API Integration:
@@ -78,18 +78,20 @@ The workflow system in Planar is a sophisticated orchestration framework that en
 
   Planar builds on Python's async/await system but adds durability. When you create a workflow:
 
+```python
   @workflow
   async def process_order(order_id: str):
       # workflow steps
+  ```
 
   The system:
 
-  1. Enforces that all workflows and steps must be coroutines (async def)
-  2. Accesses the underlying generator of the coroutine via coro.__await__()
-  3. Manually drives this generator by calling next(gen) and gen.send(result)
+  1. Enforces that all workflows and steps must be coroutines (`async def`)
+  2. Accesses the underlying generator of the coroutine via `coro.__await__()`
+  3. Manually drives this generator by calling `next(gen)` and `gen.send(result)`
   4. Intercepts any values yielded from the coroutine to implement suspension
 
-  The execute() function (lines 278-335) is the core that drives coroutine execution. It:
+  The `execute()` function (lines 278-335) is the core that drives coroutine execution. It:
   - Takes control of the coroutine's generator
   - Processes each yielded value
   - Handles regular awaits vs. suspensions differently
@@ -99,6 +101,7 @@ The workflow system in Planar is a sophisticated orchestration framework that en
 
   The Suspend class (lines 55-72) enables pausing workflows:
 
+```python
   class Suspend:
       def __init__(self, *, wakeup_at=None, interval=None):
           # Set when to wake up
@@ -106,36 +109,42 @@ The workflow system in Planar is a sophisticated orchestration framework that en
       def __await__(self):
           result = yield self
           return result
+```
 
   When you call:
+  ```python
   await suspend(interval=timedelta(minutes=5))
+  ```
 
   What happens:
-  1. The suspend() function uses the @step() decorator to mark it as resumable
+  1. The `suspend()` function uses the `@step()` decorator to mark it as resumable
   2. Inside it creates and awaits a Suspend object
-  3. The __await__ method yields self (the Suspend instance) to the executor
-  4. The execute() function detects this is a Suspend object (lines 303-307)
+  3. The `__await__` method yields self (the Suspend instance) to the executor
+  4. The `execute()` function detects this is a Suspend object (lines 303-307)
   5. It sets the workflow status to SUSPENDED and persists the wake-up time
-  6. Later, the orchestrator finds workflows ready to resume based on wakeup_at
+  6. Later, the orchestrator finds workflows ready to resume based on `wakeup_at`
   7. When resumed, execution continues right after the suspension point
 
   YieldWrapper
 
   The YieldWrapper class (lines 48-53) is crucial for handling regular async operations:
 
+```python
   class YieldWrapper:
       def __init__(self, value):
           self.value = value
       def __await__(self):
           return (yield self.value)
+```
 
   For non-Suspend yields (regular awaits), the system:
-  1. Wraps the yielded value in YieldWrapper
-  2. Awaits it to get the result from asyncio
+  1. Wraps the yielded value in `YieldWrapper`
+  2. Awaits it to get the result from `asyncio`
   3. Sends the result back to the workflow's generator
 
   This allows you to use normal async functions inside workflows:
 
+```python
   @workflow
   async def my_workflow():
       # This works because YieldWrapper passes through regular awaits
@@ -144,6 +153,7 @@ The workflow system in Planar is a sophisticated orchestration framework that en
       await suspend(interval=timedelta(hours=1))
       # When resumed days later, continues here
       return process_result(data)
+```
 
   The magic is that the workflow appears to be a normal async function, but the state is persisted across suspensions, allowing workflows to survive
   process restarts or even server reboots.

{planar-0.9.0.dist-info → planar-0.9.1.dist-info}/RECORD

@@ -1,8 +1,8 @@
 planar/__init__.py,sha256=FAYRGjuJOH2Y_XYFA0-BrRFjuKdPzIShNbaYwJbtu6A,499
-planar/_version.py,sha256=4bF_N3mS34eGDXoMdYuijyM1JYXxzz7J-NCugplemp0,18
-planar/app.py,sha256=1X0ZPW7nmf6RhMzQgjtyKD_WO-E4tjM7ItOP-bjvocQ,18505
+planar/_version.py,sha256=MDn0Ro0DvGxuAuRTGL8IBqcm5nbo1P640CIS7xBBu2k,18
+planar/app.py,sha256=VEs4jDlcisyOy9I9zEGMG_-Qm8ULKT36CSHjqrYit3o,18491
 planar/cli.py,sha256=2ObR5XkLGbdbnDqp5mrBzDVhSacHCNsVNSHnXkrMQzQ,9593
-planar/config.py,sha256=ghZNDqncwPK3LjvkMkv0BNnN1w-7ALpDBZWc1-JanTE,17634
+planar/config.py,sha256=6J42G9rEVUiOyCAY3EwUTU3PPmWthGTnrHMzST9TMcc,17809
 planar/dependencies.py,sha256=PH78fGk3bQfGnz-AphxH49307Y0XVgl3EY0LdGJnoik,1008
 planar/object_registry.py,sha256=RMleX5XE8OKDxlnMeyLpJ1Y280duub-tx1smR1zTlDg,3219
 planar/registry_items.py,sha256=UhZRIpbSoa_CV9OTl17pJfRLxItYp4Pxd9f5ZbJkGaM,2055
@@ -13,7 +13,7 @@ planar/test_cli.py,sha256=faR6CSuooHHyyB5Yt-p8CIr7mGtKrrU2TLQbc4Oe9bA,13834
 planar/test_config.py,sha256=HcmDu1nwKZZhzHQLGVyP9oxje-_g_XubEsvzRj28QPg,14328
 planar/test_object_config.py,sha256=izn4s2HmSDWpGtgpOTDmKeUYN2-63WDR1QtVQrT-x00,20135
 planar/test_object_registry.py,sha256=R7IwbB2GACm2HUuVZTeVY4V12XB9_JgSSeppPxiCdfs,480
-planar/test_sqlalchemy.py,sha256=F0aKqm5tStQj_Mqjh50kiLX4r7kphBFDOUDu_Iw7S3s,5573
+planar/test_sqlalchemy.py,sha256=QTloaipWiFmlLTBGH6YCRkwi1R27gmQZnwprO7lPLfU,7058
 planar/test_utils.py,sha256=gKenXotj36SN_bb3bQpYPfD8t06IjnGBQqEgWpujHcA,3086
 planar/utils.py,sha256=v7q9AJyWgQWl9VPSN_0qxw3rBvYe-_Pb_KcwqSsjOFU,3103
 planar/ai/__init__.py,sha256=ABOKvqQOLlVJkptcvXcuLjVZZWEsK8h-1RyFGK7kib8,231
@@ -26,18 +26,18 @@ planar/ai/test_agent_serialization.py,sha256=zYLIxhYdFhOZzBrEBoQNyYLyNcNxWwaMTkj
 planar/ai/utils.py,sha256=WVBW0TGaoKytC4bNd_a9lXrBf5QsDRut4GBcA53U2Ww,3116
 planar/data/__init__.py,sha256=LwrWl925w1CN0aW645Wpj_kDp0B8j5SsPzjr9iyrcmI,285
 planar/data/config.py,sha256=zp6ChI_2MUMbupEVQNY-BxzcdLvejXG33DCp0BujGVU,1209
-planar/data/dataset.py,sha256=5SdOh7NzJdTpuleNkoA_UA-C4WJM8mcNLcvGsRIiqIs,10150
+planar/data/dataset.py,sha256=P0NVE2OvJcXMKqVylYczY2lSGR0pSWlPAHM_upKoBWQ,9507
 planar/data/exceptions.py,sha256=AlhGQ_TReyEzfPSlqoXCjoZ1206Ut7dS4lrukVfGHaw,358
 planar/data/test_dataset.py,sha256=w2kay2PE-BhkryM3cOKX0nzSr2G0nCJxDuW1QCeFbyk,9985
 planar/db/__init__.py,sha256=SNgB6unQ1f1E9dB9O-KrsPsYM17KLsgOW1u0ajqs57I,318
 planar/db/alembic.ini,sha256=8G9IWbmF61Vwp1BXbkNOXTTgCEUMBQhOK_e-nnpnSYY,4309
-planar/db/db.py,sha256=dELx4CHZkOAxFgHsW8qPlx2kUZ8J7cTlU6rHljMV_vg,12102
+planar/db/db.py,sha256=VNpHH1R62tdWVLIV1I2ULmw3B8M6-RsM2ALG3VAVjSg,12790
 planar/db/alembic/env.py,sha256=cowI6O_4BMJPqDAukkbg69lzdsE44soi3ysxKGXbS_w,5207
 planar/db/alembic/script.py.mako,sha256=Cl7ixgLNtLk1gF5xFNXOnC9YYLX4cpFd8yHtEyY0_dY,699
 planar/db/alembic/versions/3476068c153c_initial_system_tables_migration.py,sha256=1FbzJyfapjegM-Mxd3HMMVA-8zVU6AnrnzEgIoc6eoQ,13204
 planar/files/__init__.py,sha256=fms64l32M8hPK0SINXxNCykr2EpjBTcdgnezVgaCwkc,120
 planar/files/models.py,sha256=zbZvMkoqoSnn7yOo26SRtEgtlHJbFIvwSht75APHQXk,6145
-planar/files/test_files.py,sha256=2GFAz39dIf6-bhmJaDFeOpS2sZN7VnLI60ky-e170Mc,8921
+planar/files/test_files.py,sha256=nclsbLnbijCWQ-Aj8Yvo06hs72PygL1Wps7uk7716sc,8957
 planar/files/storage/azure_blob.py,sha256=PzCm8ZpyAMH9-N6VscTlLpud-CBLcQX9qC6YjbOSfZg,12316
 planar/files/storage/base.py,sha256=KO7jyKwjKg5fNSLvhxJWE-lsypv6LXXf7bgA34aflwY,2495
 planar/files/storage/config.py,sha256=jE9Dn6cG_a4x9pdaZkasOxjyWkK6hmplLrPjEsRXGLM,3473
@@ -63,13 +63,13 @@ planar/modeling/field_helpers.py,sha256=9SOHTWPzjlaiq7RF88wjug3NvAywFurcHn651YL_
 planar/modeling/json_schema_generator.py,sha256=NDqPkWQA_I7ywQXCEQfj5ub9u5KAFEcSQpXVkrCluV4,2864
 planar/modeling/mixins/__init__.py,sha256=Lwg5eL4VFfv61FRBvH5OZqIyfrSogxQlYLUDnWnSorg,320
 planar/modeling/mixins/auditable.py,sha256=WP7aDWVn1j22ZffKzYRpu23JQJ4vvHCU1qxcbgChwhc,1619
-planar/modeling/mixins/test_auditable.py,sha256=zIa63_0Y19wMF7oIvMcOj7RoIVH7ztQzis9kHFEKKR8,2912
+planar/modeling/mixins/test_auditable.py,sha256=RSYesWWBysFEWTD39-yDhww3wCe1OPN9Yt3ywGmx4d8,2912
 planar/modeling/mixins/test_timestamp.py,sha256=oLKPvr8oUdjJPJRif81nn4YV_uwbxql_ojjXdKI7j7E,4366
 planar/modeling/mixins/test_uuid_primary_key.py,sha256=t9ZoB0dS4jjJVrHic7EeEh_g3eZeYV3mr0ylv3Kr1Io,1575
 planar/modeling/mixins/timestamp.py,sha256=-eHndCWztDiOxfCI2UknmphGeoHMJVDJG1Lz4KtkQUA,1641
 planar/modeling/mixins/uuid_primary_key.py,sha256=O1BtuXk5GdsfpwTS6nGZm1GNi0pdXKQ6Kt2f5ZjiuMc,453
 planar/modeling/orm/__init__.py,sha256=QwPgToKEf_gCdjAjKKmgh0xLTHGsboK1kH1a1a0tSy0,339
-planar/modeling/orm/planar_base_entity.py,sha256=nL1kT2k__F9Lmo1SW2XEfB6vJi_Fg72u-wW1F79eFTs,959
+planar/modeling/orm/planar_base_entity.py,sha256=7X0d86mWABleTWpulnA91P80ZjlUdGd6bv-L_TIhR2Q,1151
 planar/modeling/orm/query_filter_builder.py,sha256=Q2qWojo1Pzkt3HY1DdkBINlsP7uTOg1OOSUmwlzjTs8,5335
 planar/modeling/orm/reexports.py,sha256=sP7nw8e1yp1cahpfsefO84P5n4TNnBRk1jVHuCuH4U4,290
 planar/object_config/__init__.py,sha256=8LbI3teg3jCKoUznZ7cal22C1URnHtJMpBokCHZQUWo,352
@@ -85,12 +85,12 @@ planar/routers/info.py,sha256=HQa-mumw4zitG61V9isJlZ3cMr8pEwlB54Ct_LrpJDo,4473
 planar/routers/models.py,sha256=RwXjXpJw2uyluM4Fjc34UA0Jm7J95cUjbmTTarD_P9k,4669
 planar/routers/object_config_router.py,sha256=zA8-gGBQp1-Gm3uCC4WJ6nLicFwt4CsCqCYLFp1lRN8,4802
 planar/routers/rule.py,sha256=d6giUwYRKzxQFPeoWbe8Ylp2Cxd71_uK8yoS9NrOOBg,3563
-planar/routers/test_agents_router.py,sha256=d_d_lZT5zuSxNY2MEu51SmgLRGNZ3yCpGUooAXLpEaY,6082
-planar/routers/test_files_router.py,sha256=_uYpRJkxSxyjFJAG7aj3letx25iDSkaOgZDTRHfU8TU,1559
-planar/routers/test_object_config_router.py,sha256=HBOsQZXccPuWOLCPxEsduSd93loswUsbSk3eTM6KHRc,11389
+planar/routers/test_agents_router.py,sha256=jzRCLB21YcEfhaFUos_gfRp9WDdP38_cozTQkHbi9b4,6099
+planar/routers/test_files_router.py,sha256=HfZF1zeJ9BD2jhE6s698Jo7sDpO55RJF5g1Ksup4jtM,1576
+planar/routers/test_object_config_router.py,sha256=JpzoNlNONgljmGJYtrXnhtGhKjUT3YQMhP89fnt7dn4,11406
 planar/routers/test_routes_security.py,sha256=lXHeYg_th4UaDWeANM-dzONF8p2bEtwXJYYUlftE9R8,5556
-planar/routers/test_rule_router.py,sha256=gCJO7-NVjkio-0ZHY2hNgPvubN-0NAPA3Hg5Jcrwe70,17203
-planar/routers/test_workflow_router.py,sha256=rjK1Eau-YWs3vZbuJ50Ae_8I8_8TfxQA0F8I2HeDl9o,16572
+planar/routers/test_rule_router.py,sha256=08fa4sc7RaXvQzPCQQ4LaftfXuQwoPEDzcS4lesPG2Q,17220
+planar/routers/test_workflow_router.py,sha256=w3Gl1Okr2FgKMIqcum3gD6XzVrYm82oSIj_znbtd-aQ,16592
 planar/routers/workflow.py,sha256=8R35ENZeB5Mdt7WfH2zZ75BPg2oQ9d8kL47P1qvP-7Q,18045
 planar/rules/__init__.py,sha256=lF3F8Rdf2ottjiJu0IeBdqhg1bckLhOqZFI2t-8KItM,474
 planar/rules/decorator.py,sha256=nxT17n9uwfXMOlk5lliw_cRS7Y83gMI6CQdrf_pB5yk,6666
@@ -115,10 +115,10 @@ planar/rules/test_data/warehouse_cross_docking.json,sha256=IPfcgNkY2sds301BeW6Cj
 planar/scaffold_templates/main.py.j2,sha256=HcV0PVzcyRDaJvNdDQIFiDR1MJlLquNQzNO9oNkCKDQ,322
 planar/scaffold_templates/planar.dev.yaml.j2,sha256=I5-IqX7GJm6qA91WtUMw43L4hKACqgnER_H2racim4c,998
 planar/scaffold_templates/planar.prod.yaml.j2,sha256=FahJ2atDtvVH7IUCatGq6h9hmyF8meeiWC8RLfWphOQ,867
-planar/scaffold_templates/pyproject.toml.j2,sha256=zD8UaEwK3uUYoGQuFuPZZCNdvqNS0faGrNHbD081DAU,182
+planar/scaffold_templates/pyproject.toml.j2,sha256=nFfHWLp0sFK8cqjkdwBm6Hi6xsPzTNkaBeSgdTWTS-Q,183
 planar/scaffold_templates/app/__init__.py.j2,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 planar/scaffold_templates/app/db/entities.py.j2,sha256=wg9O3JtRaRMKlDtoWHHodyNRL0s1UILvsr9fCQ_O2-4,279
-planar/scaffold_templates/app/flows/process_invoice.py.j2,sha256=nVJ5BlhOkHFEGkBuQNEF5G2P5HA1FGx25NSS5RXBUsw,1728
+planar/scaffold_templates/app/flows/process_invoice.py.j2,sha256=R3EII_O2DHV1kvffW_AApZyaS6rR9eikcpxI08XH9dI,1691
 planar/security/auth_context.py,sha256=i63JkHQ3oXNlTis7GIKRkZJbkcvZhD2jVDuO7blgbSc,5068
 planar/security/auth_middleware.py,sha256=Grrm0i2bstWZ83ukrNZsHvFbNzffN0rvbbCcb2OxRY0,5746
 planar/security/authorization.py,sha256=zoej88_VINVNSDXm7u2LJbwOpMqmXBKj_pmCaPTar7M,11721
@@ -135,7 +135,7 @@ planar/sse/hub.py,sha256=5jhfk7zdCivau3TT1MxU2qtvETSskhqEiXzt-t0sRpE,6859
 planar/sse/model.py,sha256=fU_Fx9LS2ouS6-Dj1TIF-PLGul9YratKWafoWfZR1gc,123
 planar/sse/proxy.py,sha256=aJGo_-JIeQ0xSmE4HJdulZxIgCVRsBMMXqqSqtPvTvo,9177
 planar/testing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-planar/testing/fixtures.py,sha256=UEg12Ohj2Oip94CrC_wQ9rch71wctUZ1fYNryJLsPUY,9149
+planar/testing/fixtures.py,sha256=spK7iL1NSv-d8fd139ep-SDogZR2ZycGkD_voSAPPF4,8662
 planar/testing/memory_storage.py,sha256=apcuFisC3hW9KiU3kO8zwHQ6oK9Lu20NSX5fJ0LSZUY,2824
 planar/testing/planar_test_client.py,sha256=qPkI_ZHZho_38PpdSmEjcRBO1iHcIx3dOwo7c02Am10,1979
 planar/testing/synchronizable_tracer.py,sha256=SWeta1CgwGsN5duC0FR8NyXOQ1b1L8nDpvGdjZVJ9Bg,4938
@@ -160,13 +160,13 @@ planar/workflows/step_metadata.py,sha256=7hwcIm6ot8m-iUXSYCbPmkg6bWegF6_RJ1stInv
 planar/workflows/step_testing_utils.py,sha256=WiTwxB4mM2y6dW7CJ3PlIR1BkBodSxQV7-S25pQ3Ycs,2361
 planar/workflows/sub_workflow_runner.py,sha256=EpS7DhhXRbC6ABm-Sho6Uyxh2TqCjcTPDYvcTQN4FjY,8313
 planar/workflows/test_concurrency_detection.py,sha256=yfgvLOMkPaK7EiW4ihm1KQx82Y-s9pB6uJhBfDi7PwQ,4528
-planar/workflows/test_lock_timeout.py,sha256=WAQttTjmetTLiDHb9j0o_ydvF6j4TV1SaY_iNH8Y5vk,5746
+planar/workflows/test_lock_timeout.py,sha256=H78N090wJtiEg6SaJosfRWijpX6HwnyWyNNb7WaGPe0,5746
 planar/workflows/test_serialization.py,sha256=JfaveBRQTNMkucqkTorIMGcvi8S0j6uRtboFaWpCmes,39586
 planar/workflows/test_suspend_deserialization.py,sha256=ddw2jToSJ-ebQ0RfT7KWTRMCOs1nis1lprQiGIGuaJ0,7751
 planar/workflows/test_workflow.py,sha256=KArm9m44IBXKY9j4v_O74MAweFN6jEb7tVRomziaeFU,64011
 planar/workflows/tracing.py,sha256=E7E_kj2VBQisDqrllviIshbvOmB9QcEeRwMapunqio4,2732
 planar/workflows/wrappers.py,sha256=KON6RGg1D6yStboNbuMEeTXRpPTEa8S6Elh1tOnMAlM,1149
-planar-0.9.0.dist-info/METADATA,sha256=ak3k4S6dRs-2cuotMeuTZ2Egv0syC2rHER_zL706OFk,12199
-planar-0.9.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-planar-0.9.0.dist-info/entry_points.txt,sha256=ZtFgrZ0eeoVmhLA51ESipK0nHg2t_prjW0Cm8WhpP54,95
-planar-0.9.0.dist-info/RECORD,,
+planar-0.9.1.dist-info/METADATA,sha256=dXMHhfpYKGO-5bwwHaSSJLH2LyKxODUOwj0zTtT6gnY,12303
+planar-0.9.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+planar-0.9.1.dist-info/entry_points.txt,sha256=ZtFgrZ0eeoVmhLA51ESipK0nHg2t_prjW0Cm8WhpP54,95
+planar-0.9.1.dist-info/RECORD,,