planar 0.12.0__py3-none-any.whl → 0.13.2__py3-none-any.whl

planar/ai/__init__.py

@@ -6,10 +6,12 @@ from .agent_utils import (
     agent_configuration,
     get_agent_config,
 )
+from .tool_context import get_tool_context
 
 __all__ = [
     "Agent",
     "AgentRunResult",
     "agent_configuration",
     "get_agent_config",
+    "get_tool_context",
 ]

planar/ai/agent.py

@@ -50,8 +50,8 @@ class AgentWorkflowNotifier(AgentEventEmitter):
 class Agent[
     TInput: BaseModel | str,
     TOutput: BaseModel | str,
-    TDeps,
-](AgentBase[TInput, TOutput, TDeps]):
+    TToolContext,
+](AgentBase[TInput, TOutput, TToolContext]):
     model: models.KnownModelName | models.Model = "openai:gpt-4o"
 
     async def run_step(

planar/ai/agent_base.py

@@ -1,5 +1,3 @@
-from __future__ import annotations
-
 import abc
 from dataclasses import dataclass, field
 from typing import (
@@ -15,7 +13,7 @@ from pydantic import BaseModel
 from pydantic_ai.settings import ModelSettings
 
 from planar.ai.models import AgentConfig, AgentEventEmitter, AgentRunResult
-from planar.ai.state import delete_state, set_state
+from planar.ai.tool_context import clear_tool_context, set_tool_context
 from planar.logging import get_logger
 from planar.modeling.field_helpers import JsonSchema
 from planar.utils import P, R, T, U
@@ -30,7 +28,7 @@ class AgentBase[
     # TODO: add `= str` default when we upgrade to 3.13
     TInput: BaseModel | str,
     TOutput: BaseModel | str,
-    TState,
+    TToolContext,
 ](abc.ABC):
     """An LLM-powered agent that can be called directly within workflows."""
 
@@ -47,7 +45,7 @@ class AgentBase[
     )
     event_emitter: AgentEventEmitter | None = None
     durable: bool = True
-    state_type: Type[TState] | None = None
+    tool_context_type: Type[TToolContext] | None = None
 
     # TODO: move here to serialize to frontend
     #
@@ -94,16 +92,16 @@ class AgentBase[
 
     @overload
     async def __call__(
-        self: "AgentBase[TInput, str, TState]",
+        self: "AgentBase[TInput, str, TToolContext]",
         input_value: TInput,
-        state: TState | None = None,
+        tool_context: TToolContext | None = None,
     ) -> AgentRunResult[str]: ...
 
     @overload
     async def __call__(
-        self: "AgentBase[TInput, TOutput, TState]",
+        self: "AgentBase[TInput, TOutput, TToolContext]",
         input_value: TInput,
-        state: TState | None = None,
+        tool_context: TToolContext | None = None,
     ) -> AgentRunResult[TOutput]: ...
 
     def as_step_if_durable(
@@ -125,7 +123,7 @@ class AgentBase[
     async def __call__(
         self,
         input_value: TInput,
-        state: TState | None = None,
+        tool_context: TToolContext | None = None,
     ) -> AgentRunResult[Any]:
         if self.input_type is not None and not isinstance(input_value, self.input_type):
             raise ValueError(
@@ -153,22 +151,25 @@ class AgentBase[
                 return_type=AgentRunResult[self.output_type],
             )
 
-        if state is not None:
-            if self.state_type is None:
-                raise ValueError("state cannot be provided when state_type is not set")
-            if not isinstance(state, self.state_type):
+        if tool_context is not None:
+            if self.tool_context_type is None:
+                raise ValueError(
+                    "tool_context cannot be provided when tool_context_type is not set"
+                )
+            if not isinstance(tool_context, self.tool_context_type):
                 raise ValueError(
-                    f"state must be of type {self.state_type}, but got {type(state)}"
+                    f"tool_context must be of type {self.tool_context_type}, "
+                    f"but got {type(tool_context)}"
                 )
-            set_state(cast(TState, state))
+            set_tool_context(cast(TToolContext, tool_context))
 
         try:
             result = await run_step(input_value=input_value)
             # Cast the result to ensure type compatibility
             return cast(AgentRunResult[TOutput], result)
         finally:
-            if state is not None:
-                delete_state()
+            if tool_context is not None:
+                clear_tool_context()
 
     @abc.abstractmethod
     async def run_step(

planar/ai/{state.py → tool_context.py}

@@ -5,13 +5,13 @@ from planar.task_local import TaskLocal
 data: TaskLocal[Any] = TaskLocal()
 
 
-def set_state(ctx: Any):
+def set_tool_context(ctx: Any):
     return data.set(ctx)
 
 
-def get_state[T](_: Type[T]) -> T:
+def get_tool_context[T](_: Type[T]) -> T:
     return cast(T, data.get())
 
 
-def delete_state():
+def clear_tool_context():
     return data.clear()

planar/cli.py

@@ -262,6 +262,11 @@ def run_command(
 def scaffold_project(
     name: str = typer.Option(None, "--name", help="Name of the new project"),
     directory: Path = typer.Option(Path("."), "--directory", help="Target directory"),
+    use_local_source: bool = typer.Option(
+        False,
+        "--use-local-source",
+        help="Use local planar source instead of published package (for development)",
+    ),
 ):
     """
     Creates a new Planar project with a basic structure and example workflow.
@@ -278,8 +283,19 @@ def scaffold_project(
     template_dir = Path(__file__).parent / "scaffold_templates"
     jinja_env = JinjaEnvironment(loader=FileSystemLoader(template_dir))
 
+    planar_source_path = None
+    if use_local_source:
+        # Assume we're running from the planar package itself
+        # Go up from planar/cli.py -> planar/ -> planar_repo/
+        planar_source_path = Path(__file__).parent.parent.resolve()
+        typer.echo(f"Using local planar source: {planar_source_path}")
+
     # Template context
-    context = {"name": name}
+    context = {
+        "name": name,
+        "local_source": use_local_source,
+        "planar_source_path": planar_source_path,
+    }
 
     # Create project structure
     try:

planar/config.py

@@ -3,6 +3,7 @@ import logging
 import logging.config
 import os
 import sys
+from contextlib import contextmanager
 from enum import Enum
 from pathlib import Path
 from typing import Annotated, Any, Dict, Literal
@@ -24,6 +25,7 @@ from sqlalchemy import URL, make_url
 from planar.data.config import DataConfig
 from planar.files.storage.config import LocalDirectoryConfig, StorageConfig
 from planar.logging import get_logger
+from planar.logging.formatter import StructuredFormatter
 
 logger = get_logger(__name__)
 
@@ -144,12 +146,12 @@ class CorsConfig(BaseModel):
     allow_headers: list[str]
 
     @model_validator(mode="after")
-    def validate_allow_origins(cls, instance):
-        if instance.allow_credentials and "*" in instance.allow_origins:
+    def validate_allow_origins(self):
+        if self.allow_credentials and "*" in self.allow_origins:
             raise ValueError(
                 "allow_credentials cannot be True if allow_origins includes '*'. Must explicitly specify allowed origins."
             )
-        return instance
+        return self
 
 
 LOCAL_CORS_CONFIG = CorsConfig(
@@ -173,10 +175,10 @@ class JWTConfig(BaseModel):
     additional_exclusion_paths: list[str] | None = Field(default_factory=list)
 
     @model_validator(mode="after")
-    def validate_client_id(cls, instance):
-        if not instance.client_id or not instance.org_id:
+    def validate_client_id(self):
+        if not self.client_id or not self.org_id:
             raise ValueError("Both client_id and org_id required to enable JWT")
-        return instance
+        return self
 
 
 # Coplane ORG JWT config
@@ -235,12 +237,12 @@ class PlanarConfig(BaseModel):
     model_config = ConfigDict(extra="forbid")
 
     @model_validator(mode="after")
-    def validate_db_connection_reference(cls, instance):
-        if instance.app.db_connection not in instance.db_connections:
+    def validate_db_connection_reference(self):
+        if self.app.db_connection not in self.db_connections:
             raise ValueError(
-                f"Invalid db_connection reference: {instance.app.db_connection}"
+                f"Invalid db_connection reference: {self.app.db_connection}"
             )
-        return instance
+        return self
 
     def connection_url(self) -> URL:
         connection = self.db_connections[self.app.db_connection]
@@ -460,6 +462,28 @@ def load_environment_aware_env_vars() -> None:
             return
 
 
+@contextmanager
+def _temporary_config_logging():
+    """Install a console handler so config loading logs are visible before configuration."""
+    root_logger = logging.getLogger()
+    handler = logging.StreamHandler(sys.stderr)
+    handler.setFormatter(StructuredFormatter(use_colors=sys.stderr.isatty()))
+    handler.setLevel(logging.NOTSET)
+
+    previous_level = root_logger.level
+    if root_logger.getEffectiveLevel() > logging.INFO:
+        root_logger.setLevel(logging.INFO)
+
+    root_logger.addHandler(handler)
+
+    try:
+        yield
+    finally:
+        root_logger.removeHandler(handler)
+        handler.close()
+        root_logger.setLevel(previous_level)
+
+
 def load_environment_aware_config[ConfigClass]() -> PlanarConfig:
     """
     Load configuration based on environment settings, using environment variables
@@ -476,83 +500,87 @@ def load_environment_aware_config[ConfigClass]() -> PlanarConfig:
     Raises:
         InvalidConfigurationError: If configuration loading or validation fails.
     """
-    load_environment_aware_env_vars()
-    env = get_environment()
-
-    if env == "dev":
-        base_config = sqlite_config(db_path="planar_dev.db")
-        base_config.security = SecurityConfig(cors=LOCAL_CORS_CONFIG)
-        base_config.environment = Environment.DEV
-    else:
-        base_config = sqlite_config(db_path="planar.db")
-        base_config.environment = Environment.PROD
-        base_config.security = SecurityConfig(
-            cors=PROD_CORS_CONFIG, jwt=JWT_COPLANE_CONFIG
-        )
+    with _temporary_config_logging():
+        load_environment_aware_env_vars()
+        env = get_environment()
+
+        if env == "dev":
+            base_config = sqlite_config(db_path="planar_dev.db")
+            base_config.security = SecurityConfig(cors=LOCAL_CORS_CONFIG)
+            base_config.environment = Environment.DEV
+        else:
+            base_config = sqlite_config(db_path="planar.db")
+            base_config.environment = Environment.PROD
+            base_config.security = SecurityConfig(
+                cors=PROD_CORS_CONFIG, jwt=JWT_COPLANE_CONFIG
+            )
 
-    # Convert base config to dict for merging
-    # Use by_alias=False to work with Python field names before validation
-    base_dict = base_config.model_dump(mode="python", by_alias=False)
+        # Convert base config to dict for merging
+        # Use by_alias=False to work with Python field names before validation
+        base_dict = base_config.model_dump(mode="python", by_alias=False)
 
-    override_config_path = get_config_path()
-    if override_config_path:
-        if not override_config_path.exists():
-            raise InvalidConfigurationError(
-                f"Configuration file not found: {override_config_path}"
+        override_config_path = get_config_path()
+        if override_config_path:
+            if not override_config_path.exists():
+                raise InvalidConfigurationError(
+                    f"Configuration file not found: {override_config_path}"
+                )
+        else:
+            paths_to_check = []
+            if os.environ.get("PLANAR_ENTRY_POINT"):
+                # Extract the directory from the entry point path
+                entry_point_dir = Path(os.environ["PLANAR_ENTRY_POINT"]).parent
+                paths_to_check = [
+                    entry_point_dir / f"planar.{env}.yaml",
+                    entry_point_dir / "planar.yaml",
+                ]
+            paths_to_check.append(Path(f"planar.{env}.yaml"))
+            paths_to_check.append(Path("planar.yaml"))
+
+            override_config_path = next(
+                (path for path in paths_to_check if path.exists()), None
             )
-    else:
-        paths_to_check = []
-        if os.environ.get("PLANAR_ENTRY_POINT"):
-            # Extract the directory from the entry point path
-            entry_point_dir = Path(os.environ["PLANAR_ENTRY_POINT"]).parent
-            paths_to_check = [
-                entry_point_dir / f"planar.{env}.yaml",
-                entry_point_dir / "planar.yaml",
-            ]
-        paths_to_check.append(Path(f"planar.{env}.yaml"))
-        paths_to_check.append(Path("planar.yaml"))
-
-        override_config_path = next(
-            (path for path in paths_to_check if path.exists()), None
-        )
-        if override_config_path is None:
-            logger.warning(
-                "no override config file found, using default config",
-                search_paths=[str(p) for p in paths_to_check],
-                env=env,
+            if override_config_path is None:
+                logger.warning(
+                    "no override config file found, using default config",
+                    search_paths=[str(p) for p in paths_to_check],
+                    env=env,
+                )
+
+        merged_dict = base_dict
+        if override_config_path and override_config_path.exists():
+            logger.info(
+                "using override config file", override_config_path=override_config_path
             )
+            try:
+                # We can't use load_config_from_file here because we expect
+                # the override config to not be a fully validated PlanarConfig object,
+                # and we need to merge it onto the base default config.
+                with open(override_config_path, "r") as f:
+                    override_yaml_str = f.read()
+
+                # Expand environment variables in the YAML string
+                processed_yaml_str = os.path.expandvars(override_yaml_str)
+                logger.debug(
+                    "processed override yaml string",
+                    processed_yaml_str=processed_yaml_str,
+                )
+
+                override_dict = yaml.safe_load(processed_yaml_str) or {}
+                logger.debug("loaded override config", override_dict=override_dict)
+
+                # Deep merge the override onto the base dictionary
+                merged_dict = deep_merge_dicts(override_dict, base_dict)
+                logger.debug("merged config dict", merged_dict=merged_dict)
+            except yaml.YAMLError as e:
+                raise InvalidConfigurationError(
+                    f"Error parsing override configuration file {override_config_path}: {e}"
+                ) from e
 
-    merged_dict = base_dict
-    if override_config_path and override_config_path.exists():
-        logger.info(
-            "using override config file", override_config_path=override_config_path
-        )
         try:
-            # We can't use load_config_from_file here because we expect
-            # the override config to not be a fully validated PlanarConfig object,
-            # and we need to merge it onto the base default config.
-            with open(override_config_path, "r") as f:
-                override_yaml_str = f.read()
-
-            # Expand environment variables in the YAML string
-            processed_yaml_str = os.path.expandvars(override_yaml_str)
-            logger.debug(
-                "processed override yaml string", processed_yaml_str=processed_yaml_str
-            )
-
-            override_dict = yaml.safe_load(processed_yaml_str) or {}
-            logger.debug("loaded override config", override_dict=override_dict)
-
-            # Deep merge the override onto the base dictionary
-            merged_dict = deep_merge_dicts(override_dict, base_dict)
-            logger.debug("merged config dict", merged_dict=merged_dict)
-        except yaml.YAMLError as e:
+            final_config = PlanarConfig.model_validate(merged_dict)
+            return final_config
+        except ValidationError as e:
             raise InvalidConfigurationError(
-                f"Error parsing override configuration file {override_config_path}: {e}"
+                f"Configuration validation error: {e}"
             ) from e
-
-    try:
-        final_config = PlanarConfig.model_validate(merged_dict)
-        return final_config
-    except ValidationError as e:
-        raise InvalidConfigurationError(f"Configuration validation error: {e}") from e

planar/data/connection.py

@@ -1,5 +1,6 @@
 import asyncio
 from dataclasses import dataclass
+from urllib.parse import urlparse
 
 import ibis
 from ibis.backends.duckdb import Backend as DuckDBBackend
@@ -55,6 +56,48 @@ async def _close_backend(connection: DuckDBBackend) -> None:
         logger.warning("failed to close DuckDB connection", error=str(exc))
 
 
+def _make_aws_s3_secret_query(config: S3Config) -> str:
+    """
+    https://duckdb.org/docs/stable/core_extensions/httpfs/s3api
+    """
+    columns = ["TYPE s3"]
+
+    if config.region:
+        columns.append(
+            f"REGION '{config.region}'",
+        )
+
+    if config.endpoint_url:
+        parsed_url = urlparse(config.endpoint_url)
+        endpoint_host = parsed_url.hostname
+        endpoint_port = f":{parsed_url.port}" if parsed_url.port else ""
+        endpoint = f"{endpoint_host}{endpoint_port}"
+
+        columns.append(f"ENDPOINT '{endpoint}'")
+
+    if config.access_key and config.secret_key:
+        columns.extend(
+            [
+                "PROVIDER config",
+                f"KEY_ID '{config.access_key}'",
+                f"SECRET '{config.secret_key}'",
+            ]
+        )
+    else:
+        columns.extend(
+            [
+                "PROVIDER credential_chain",
+                "CHAIN 'env;sts;instance'",
+            ]
+        )
+
+    return f"""
+        CREATE OR REPLACE SECRET secret (
+        {", ".join(columns)}
+        );
+    """
+
+
 async def _create_connection(config: PlanarConfig) -> DuckDBBackend:
     """Create Ibis DuckDB connection with Ducklake."""
     data_config = config.data
@@ -105,6 +148,14 @@ async def _create_connection(config: PlanarConfig) -> DuckDBBackend:
     if isinstance(storage, LocalDirectoryConfig):
         data_path = storage.directory
     elif isinstance(storage, S3Config):
+        await asyncio.to_thread(con.raw_sql, "INSTALL httpfs;")
+        await asyncio.to_thread(con.raw_sql, "LOAD httpfs;")
+
+        await asyncio.to_thread(
+            con.raw_sql,
+            _make_aws_s3_secret_query(storage),
+        )
+
         data_path = f"s3://{storage.bucket_name}/"
     else:
         # Generic fallback

planar/human/__init__.py

@@ -1,2 +1,11 @@
-from .human import Human, Timeout, complete_human_task, get_human_tasks  # noqa: F401
-from .models import HumanTask, HumanTaskResult  # noqa: F401
+from .human import Human, Timeout, complete_human_task, get_human_tasks
+from .models import HumanTask, HumanTaskResult
+
+__all__ = [
+    "Human",
+    "Timeout",
+    "complete_human_task",
+    "get_human_tasks",
+    "HumanTask",
+    "HumanTaskResult",
+]

planar/human/models.py

@@ -7,7 +7,6 @@ from pydantic import BaseModel
 from sqlmodel import JSON, Column, Field
 
 from planar.db import PlanarInternalBase
-from planar.modeling.field_helpers import JsonSchema
 from planar.modeling.mixins import TimestampMixin
 from planar.modeling.mixins.auditable import AuditableMixin
 from planar.modeling.mixins.uuid_primary_key import UUIDPrimaryKeyMixin
@@ -48,12 +47,12 @@ class HumanTask(
     workflow_name: str
 
     # Input data for context
-    input_schema: Optional[JsonSchema] = Field(default=None, sa_column=Column(JSON))
+    input_schema: Optional[dict[str, Any]] = Field(default=None, sa_column=Column(JSON))
     input_data: Optional[dict[str, Any]] = Field(default=None, sa_column=Column(JSON))
     message: Optional[str] = Field(default=None)
 
     # Schema for expected output
-    output_schema: JsonSchema = Field(sa_column=Column(JSON))
+    output_schema: dict[str, Any] = Field(sa_column=Column(JSON))
     output_data: Optional[dict[str, Any]] = Field(default=None, sa_column=Column(JSON))
 
     # Suggested data for the form (optional)

planar/logging/attributes.py

@@ -18,6 +18,7 @@ def _in_event_loop_task() -> bool:
         return (
             threading.main_thread() == threading.current_thread()
             and asyncio.get_running_loop() is not None
+            and asyncio.current_task() is not None
         )
     except RuntimeError:
         return False

planar/scaffold_templates/pyproject.toml.j2

@@ -3,8 +3,16 @@ name = "{{ name }}"
 version = "0.1.0"
 requires-python = ">=3.12"
 dependencies = [
-    "planar[data]>=0.10.0",
+{%- if local_source %}
+    "planar",
+{%- else %}
+    "planar>=0.10.0",
+{%- endif %}
 ]
 
-[[tool.uv.index]]
-url = "https://coplane.github.io/planar/simple/"
+{%- if local_source %}
+
+[tool.uv.sources]
+planar = { path = "{{ planar_source_path }}", editable = true }
+
+{%- endif %}

planar/sse/proxy.py

@@ -178,7 +178,13 @@ class SSEProxy:
             # builtin hub. That's why we check for self.builtin_process instead of
             # self.enable_builtin_hub. Also helps with type checking.
             logger.info("terminating builtin sse hub process")
-            self.builtin_process.terminate()
+            try:
+                self.builtin_process.terminate()
+            except AttributeError:
+                # Race condition: _popen may be None if process already terminated.
+                # This can happen when stop() is called multiple times during shutdown.
+                logger.debug("process already terminated or cleaned up")
+            self.builtin_process = None
 
     def setup_proxy_endpoint(self):
         @self.router.get("/")

planar/workflows/notifications.py

@@ -104,11 +104,15 @@ def agent_notify(kind: Notification, data: str):
     if callback is not None:
         context = get_context()
         logger.debug("notifying agent event", kind=kind)
+        if context.step_stack:
+            step_id = context.step_stack[-1].step_id
+        else:
+            step_id = -1
         callback(
             WorkflowNotification(
                 kind=kind,
                 workflow_id=context.workflow_id,
-                data=AgentEventData(data=data, step_id=context.step_stack[-1].step_id),
+                data=AgentEventData(data=data, step_id=step_id),
             )
         )
 

{planar-0.12.0.dist-info → planar-0.13.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: planar
-Version: 0.12.0
+Version: 0.13.2
 Summary: Batteries-included framework for building durable agentic workflows and business applications.
 License-Expression: LicenseRef-Proprietary
 Requires-Dist: aiofiles>=24.1.0
@@ -25,6 +25,7 @@ Requires-Dist: zen-engine>=0.40.0
 Requires-Dist: azure-storage-blob>=12.19.0 ; extra == 'azure'
 Requires-Dist: azure-identity>=1.15.0 ; extra == 'azure'
 Requires-Dist: aiohttp>=3.8.0 ; extra == 'azure'
+Requires-Dist: duckdb>=1.3,<1.4 ; extra == 'data'
 Requires-Dist: ducklake>=0.1.1 ; extra == 'data'
 Requires-Dist: ibis-framework[duckdb]>=10.8.0 ; extra == 'data'
 Requires-Dist: polars>=1.31.0 ; extra == 'data'

{planar-0.12.0.dist-info → planar-0.13.2.dist-info}/RECORD

@@ -1,18 +1,18 @@
 planar/__init__.py,sha256=FAYRGjuJOH2Y_XYFA0-BrRFjuKdPzIShNbaYwJbtu6A,499
-planar/ai/__init__.py,sha256=ABOKvqQOLlVJkptcvXcuLjVZZWEsK8h-1RyFGK7kib8,231
-planar/ai/agent.py,sha256=HAyQvdA-NOEYMtze3Gh_BtOzk-rD1DXnv1jNGWd-9dA,12499
-planar/ai/agent_base.py,sha256=5UURilfMldIYoTNzwlSY9eVaub5LDovCGFeAszyuGWE,6198
+planar/ai/__init__.py,sha256=lgGmY3ffmKqt35JncZmJOK5jWZ0bJRAksR54hYqV8is,298
+planar/ai/agent.py,sha256=xNJiQV-FC1BVkIBb9zpIy8NKN7jQl1j21TMiACyxBZg,12513
+planar/ai/agent_base.py,sha256=0P4vjTvka8MERP9z360J4nGd-TAfeafK9zczbhcvU9k,6410
 planar/ai/agent_utils.py,sha256=MYNerdAm2TPVbDSKAmBCUlGmR56NAc8seZmDAFOWvUA,4199
 planar/ai/models.py,sha256=bZd4MoBBJMqzXJqsmsbMdZtOaRrNeX438CHAqOvmpfw,4598
 planar/ai/pydantic_ai.py,sha256=FpD0pE7wWNYwmEUZ90D7_J8gbAoqKmWtrLr2fhAd7rg,23503
-planar/ai/state.py,sha256=6vQ8VMLxJYB75QXkm8AVPkdXHUMwwjKxBWH-hGIK9p0,278
+planar/ai/tool_context.py,sha256=9W7VFrHPhNeieEvlJlv-OrFPVzySItdUjKCutkXpYFU,298
 planar/ai/utils.py,sha256=WVBW0TGaoKytC4bNd_a9lXrBf5QsDRut4GBcA53U2Ww,3116
 planar/app.py,sha256=2ijbrORCfjKReDieLbwgey_9poJJwEfWkvCNKcVYcdk,19484
-planar/cli.py,sha256=9LINDDiAUBDmzWQY9BuCYTssM7eb-ypa5bL9HAY3Ld8,10500
-planar/config.py,sha256=6J42G9rEVUiOyCAY3EwUTU3PPmWthGTnrHMzST9TMcc,17809
+planar/cli.py,sha256=GONw7Dpyxy_7Vf48rLmQXRQnC_IyWENRULQF0DwiCuY,11108
+planar/config.py,sha256=54N-qPaxihEn6QUQvXsdtbEN-pTTrd_5NG8WFYb0CRI,18879
 planar/data/__init__.py,sha256=eqSREzJ58HM05DXpR_00M6RDFxtHSIh-OEuqXBPVsVc,362
 planar/data/config.py,sha256=oaLiwN3OUt3i85MS0zxpdMNG5VjaM5xB6VtPc1f4MFU,1484
-planar/data/connection.py,sha256=OQL-EEBtfEOtN5PYZA5TswCTD8Cebt9-pP_w5Qifs24,6705
+planar/data/connection.py,sha256=QPcbomoWDdttu28cfeQAtnUdc_ptayQTaqwcC8Gq4vc,8056
 planar/data/dataset.py,sha256=f-x9cOuGyQQldC98mCwpFVOXMiDNN6LQDQ9vtljXVRo,6095
 planar/data/exceptions.py,sha256=AlhGQ_TReyEzfPSlqoXCjoZ1206Ut7dS4lrukVfGHaw,358
 planar/data/utils.py,sha256=NhxJFSxPLNX1ddSANS3-bVhMr1Q_-25qDRRXxGug4Vc,6312
@@ -32,11 +32,11 @@ planar/files/storage/config.py,sha256=lzODgufhZliwQDikqMQCX3KKiap0CL6Cc9qbIdeUMC
 planar/files/storage/context.py,sha256=Qadlz4T-FQ1A0TdGsOfuNmM679ohayU7oaexUpT8AY0,361
 planar/files/storage/local_directory.py,sha256=1SsEfr0Ud9TvSQJneDl_M-D7AFYixLE9t-bVIiY3aSI,7395
 planar/files/storage/s3.py,sha256=1861rSw3kplXtugUWD7mdSD_EnPSHME1mGc82V69r5g,8234
-planar/human/__init__.py,sha256=FwpV-FFssKKlvKSjWoI4gJB1XTMaNb1UNCSBxjAtIBw,147
+planar/human/__init__.py,sha256=SOdDlIvf4QOz_wGhJ_w-7v6b1daJHbO785TsJUVAzOc,252
 planar/human/human.py,sha256=-oRtN_8bCtSV7Sxku7yG4rof7T5pr4j18Cfm3u4Z3PM,14925
-planar/human/models.py,sha256=Cec1Y9NGGtuAl1ZhqNc9PWIq__BbiWVTh7IYKR4yl3w,2317
+planar/human/models.py,sha256=uYqH79qgwH2HM6BO7dR54WFcvleVCfpZOYRSNJZ9P2o,2272
 planar/logging/__init__.py,sha256=BW101gskQS3C2agKSDiJEy4L-j5z6BP1AwEfd2JMXHM,254
-planar/logging/attributes.py,sha256=SB-lC-Osa55zXkX2UAWm56vKXvHgbF7TmhGnSiBWejk,1529
+planar/logging/attributes.py,sha256=4JCmncF46MbGt6q4wD60DZss8eBWDdKDvxS8w8lE9fc,1580
 planar/logging/context.py,sha256=mGVpL-276VWpRUIGlkGwbn9gkATqFS7lcFn1aM0v-eQ,384
 planar/logging/formatter.py,sha256=NMDhpo7ezsfGO7cPwOWbClqODviEgSjqHCoqrCCIu2c,3560
 planar/logging/logger.py,sha256=vj3-z2ea0J1ppgDpJBsrueA3jg5kjk9ceIo-4tWarXk,2650
@@ -81,7 +81,7 @@ planar/scaffold_templates/app/flows/process_invoice.py.j2,sha256=R3EII_O2DHV1kvf
 planar/scaffold_templates/main.py.j2,sha256=zrqsuv3Fp4lcknvB37RrRHy11msdFB1yDguYmTLLPhw,398
 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=HpBc3cuTr-VeVN3BQ8y1Vr2eOtkL7TLH5mNz_T-akpA,190
+planar/scaffold_templates/pyproject.toml.j2,sha256=XdOf3B_fkTDwEzQsneNdmC43rptmZoqwFRj7QpaL7OI,299
 planar/security/auth_context.py,sha256=i63JkHQ3oXNlTis7GIKRkZJbkcvZhD2jVDuO7blgbSc,5068
 planar/security/auth_middleware.py,sha256=Grrm0i2bstWZ83ukrNZsHvFbNzffN0rvbbCcb2OxRY0,5746
 planar/security/authorization.py,sha256=zTh5rLmVJZnGDq540_1WYljJ7Hws-BY_P6VqUCONqLE,12760
@@ -92,7 +92,7 @@ planar/sse/constants.py,sha256=jE3SooTEWPuuL_Bi6DisJYMR9pKOiHVfboU2h5QTJRg,22
 planar/sse/example.html,sha256=SgTJbdJ3B1F1DxLC2YWuX2F1XVwKcTjX34CbJCXoCTM,4144
 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/sse/proxy.py,sha256=LgfnCjZHtnDquV5HpdoSru43pxk-T5aY9NCjQLNrrcQ,9518
 planar/task_local.py,sha256=pyvT0bdzAn15HL2yQUs9YrU5MVXh9njQt9MH51AGljs,1102
 planar/testing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 planar/testing/fixtures.py,sha256=z0VkKTqAg9z_1L_ojB0pTzKSaLPcDeNxRq_RB36rUU8,9740
@@ -112,7 +112,7 @@ planar/workflows/execution.py,sha256=8c4a2L1qRMPQrCEJ8-sEk-gJi_xKq5gYKDSWSbSspVI
 planar/workflows/lock.py,sha256=QU5_y_n8RHOC7ppLicH7yWX-Ni7N93hlB14D2zXOQ8A,8773
 planar/workflows/misc.py,sha256=g3XVRMeU9mgDRi_6RgFdydLEqvTAg49wbIGlmC7kOu8,140
 planar/workflows/models.py,sha256=SKBJTGhd4nVWxtlDkaQrU2RvRTtoj07PJhLT73cF_ac,5591
-planar/workflows/notifications.py,sha256=JrObfWD-uRZJlZLMSDJDqjDuXfYAoRSLfgEeyoy98Vs,3795
+planar/workflows/notifications.py,sha256=APAUKk1-Y7R5E1LHA4RWQK5Z6vh2lIvf5tHYWwhD5WM,3895
 planar/workflows/orchestrator.py,sha256=rneB1yOPDZiJcHFbD6UDZ4juU77iSBK1eu1gOFm58vM,15480
 planar/workflows/query.py,sha256=38B5SLwXf3AlA_1ChR5DicFWdcUqzpQzMkuAUCNHafI,8838
 planar/workflows/serialization.py,sha256=v3eqUS0odUFS7PnIrKyKUrK-feIv0ssxEp2VxjkddyI,13733
@@ -122,7 +122,7 @@ planar/workflows/step_testing_utils.py,sha256=WiTwxB4mM2y6dW7CJ3PlIR1BkBodSxQV7-
 planar/workflows/sub_workflow_runner.py,sha256=EpS7DhhXRbC6ABm-Sho6Uyxh2TqCjcTPDYvcTQN4FjY,8313
 planar/workflows/tracing.py,sha256=E7E_kj2VBQisDqrllviIshbvOmB9QcEeRwMapunqio4,2732
 planar/workflows/wrappers.py,sha256=dY_3NqkzGMG4jgX2lkAqvHTYFA1lBzhkQCw7N5CyaQM,1174
-planar-0.12.0.dist-info/WHEEL,sha256=-neZj6nU9KAMg2CnCY6T3w8J53nx1kFGw_9HfoSzM60,79
-planar-0.12.0.dist-info/entry_points.txt,sha256=L3T0w9u2UPKWXv6JbXFWKU1d5xyEAq1xVWbpYS6mLNg,96
-planar-0.12.0.dist-info/METADATA,sha256=QzYhhuXw0VLyymqS31qadZ_DeIYbG7v93MZAe5t2Esw,7285
-planar-0.12.0.dist-info/RECORD,,
+planar-0.13.2.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
+planar-0.13.2.dist-info/entry_points.txt,sha256=L3T0w9u2UPKWXv6JbXFWKU1d5xyEAq1xVWbpYS6mLNg,96
+planar-0.13.2.dist-info/METADATA,sha256=hHuWQx_u5HHzw4onoBPARIX8wVjU_PwW_ia6X5g7oPU,7335
+planar-0.13.2.dist-info/RECORD,,

{planar-0.12.0.dist-info → planar-0.13.2.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: uv 0.8.22
+Generator: uv 0.8.24
 Root-Is-Purelib: true
 Tag: py3-none-any